javalist条件查询条件

❶ java怎么实现多条件筛选

or (类型 i : list)
{
if (条件1 && 条件2){
System.out.println(i);
}
} 这个方法循环是可以的

❷ JAVA怎样从一个对象集合里面查找指定条件的对象

ArrayList底层使用数组实现的，只能先循环再判断：
for(User user:users)
{
if(user.getName().equals("test"))
{
System.out.println("找到名字为test的User")
break;

}

}

❸ java怎样判断list是否有值

isEmpty()判断有没有元素以及list是否为null，参考下面代码

if(list!=null&&!list.isEmpty()){
这个里面取list中的值
}else{
做其他处理
}

上面代码说明：根据if条件的判断，如果list存在，会做“这个里面取list中的值”的处理，如果list不存在或为空，那么会做“做其他处理”处理

❹ 如何在java List中进行模糊查询

这样一个List，里面存放的是多个Employee对象。然后我想对这个List进行按照Employee对象的名字进行模糊查询。有什么好的解决方案么？
比如我输入的查询条件为“wang”，那么应该返回只包含employee1的List列表。
List list = new ArrayList();
Employee employee1 = new Employee();
employee1.setName("wangqiang");
employee1.setAge(30);
list.add(employee1);

❺ java多条件查询问题

java多条件不定条件查询
网站或各类管理系统都会用到搜索，会用到一个或多个不确定条件搜索，单条件搜索比较简单,有时候会有多个条件共同查询，如果系统中已经提供了相关的方法供你使用最好，像我做这老系统改版，需要添加搜索，就要自己写了。开始也没管那么多，就是拼sql,但是后来发现要加搜索地方不少，总是这样写既增加了工作量，还要做很多重复工作，说不定以后还会做这样的工作，所以还是写一个比较通用的查询方法。
package com.test;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Resource;
import org.apache.poi.hssf.record.formula.functions.T;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import com.ams.bo.webapi.dto.Agent;
public class MultiTaskSearch {

@Resource(name="jdbcTemplate")
private JdbcTemplate jdbcTemplate;
@Resource(name = "storeFrontDAO")

private Map search() {
String name="公司";
String email="@163";
String invoiceTitle="公司";
int sign=1;
String at="2012-04-26";
Map<String, Object> map=new LinkedHashMap<String, Object>();//保持添加顺序
// Map<String, Object> map=new HashMap<String, Object>();//无固定顺序
map.put("name like", name);
map.put("email like", email);
map.put("invoiceTitle like", invoiceTitle);
map.put("sign =", sign);
map.put("addtime>=", at);
return map;
}

public <T> List<T> dbSearch(Class typeClass,Map<String, Object> map,String orderby) {
String paths[] = { "ams-servlet.xml" };
ApplicationContext ctx = new (paths);
jdbcTemplate = (JdbcTemplate)ctx.getBean("jdbcTemplate");

List<T> TList=null;
String tablename = typeClass.getName().substring(
typeClass.getName().lastIndexOf(".") + 1);
StringBuffer sql=new StringBuffer("select * from ");
sql.append(tablename);
if (map.size()!=0) {
sql.append(" t where 1=1");//后面只需拼接and条件
}
Set<Entry<String, Object>> set=map.entrySet();
Iterator iterator=set.iterator();
for (int i = 0; i < set.size(); i++) {
Map.Entry mapEntry=(Entry) iterator.next();
if (!"".equals(mapEntry.getValue().toString())) {

//模糊匹配
if (mapEntry.getKey().toString().contains("like")) {
// sql.append(" and t."+mapEntry.getKey()+" "+mapEntry.getValue()+" ");
sql.append(" and t."+mapEntry.getKey()+" '%"+mapEntry.getValue()+"%'");
//精确匹配
}else {
// sql.append(" and t."+mapEntry.getKey()+" '%"+mapEntry.getValue()+"%'");
sql.append(" and t."+mapEntry.getKey()+" "+mapEntry.getValue()+" ");
}
}
}
if (null!=orderby&&!"".equals(orderby)) {
sql.append(orderby);
}
System.out.println("SQL:"+sql.toString());
TList=jdbcTemplate.query(sql.toString(),new Object[] {}, new BeanPropertyRowMapper<T> (typeClass));

return TList;
}
public static void main(String[] args) {
MultiTaskSearch mt=new MultiTaskSearch();
Map map=mt.search();
String orderby=" order by addTime desc";
List<Agent> agents=mt.dbSearch(Agent.class, map,orderby);
for (Agent agent : agents) {
System.out.println(agent.getName());
}
System.out.println("****************"+agents.size());

}
}
或者可以用拼sql的方法实现
使用union关键字可以在一个文本框内搜索出多个条件的数据
select t1.* from
(
select * from agent where name like '"2%'
union
select * from agent where email like '"2%'
union
select * from agent where ContactPerson like '"2%'
) t1
这种查询结果是所有的集合，也可以把union换成or

❻ java中，获取一个list，将list里的数据按不通条件进行分类

public static void main(String[] args) {
//初始化数据
List<String> allList = new ArrayList<String>();
allList.add("学生A、语文、90分、第一学期");
allList.add("学生B、语文、80分、第一学期");
allList.add("学生A、英语、90分、第一学期");
allList.add("学生A、数学、90分、第一学期");
allList.add("学生B、英语、80分、第一学期");
allList.add("学生A、语文、90分、第二学期");
allList.add("学生B、数学、80分、第一学期");
allList.add("学生B、英语、80分、第二学期");
allList.add("学生A、数学、90分、第二学期");
allList.add("学生B、语文、80分、第二学期");
//定义姓名、学期、科目 数组
List<String> stuList = new ArrayList<String>();
List<String> subjList = new ArrayList<String>();
List<String> termList = new ArrayList<String>();
boolean stuContained = false;
boolean subjContained = false;
boolean termContained = false;
//从allList中 加载相上述三个类别，如果固定的话，可以手动指定
for (String string : allList) {
String[] strs = string.split("、");
stuContained = false;
subjContained = false;
termContained = false;
if(stuList.size()<=0) stuContained = false;
else{
for (String string2 : stuList) {
if(string2.equals(strs[0])){
stuContained = true;
break;
}
}
}
if(!stuContained)
stuList.add(strs[0]);
if(subjList.size()<=0) subjContained = false;
else{
for (String string2 : subjList) {
if(string2.equals(strs[1])){
subjContained = true;
break;
}
}
}
if(!subjContained)
subjList.add(strs[1]);
if(termList.size()<=0) termContained = false;
else{
for (String string2 : termList) {
if(string2.equals(strs[3])){
termContained = true;
break;
}
}
}
if(!termContained)
termList.add(strs[3]);
}
//构建结果数组
List<String> results = new ArrayList<String>();
String temp = "";
for (String string : stuList) {
temp ="姓名："+string;
for (String string2 : termList) {
temp += ",学期："+string2;
int score = 0;
for (String string3 : subjList) {
temp+= ","+string3+":";
for (String string4 : allList) {
String[] temps = string4.split("、");
if(temps[0].equals(string) && temps[1].equals(string3)&& temps[3].equals(string2)){
temp+= temps[2];
score += Integer.parseInt(temps[2].substring(0, temps[2].length()-1));
}
}
}
String[] temp2 = temp.split(",");
temp += ",总分：" + score +"分";
results.add(temp);
temp ="姓名："+string;
}
}
//输出结果
for (String string : results) {
System.out.println(string);
}
}

只是一种方案，又很多情况不确定，如果list中的数据可以作为javabean设置会方便些，如果数据是在数据库中的，那么使用sql语句会方便很多(上面的做法实际上是模拟了sql语句)

❼ java怎么像sql的where条件那样处理list里面的数据

public static void main(String[] args){
vo vo1 = new vo("张三",12,"武汉");
vo vo2 = new vo("李四",12,"武汉");
vo vo3 = new vo("王五",12,"北京");
List<vo> list = Arrays.asList(vo1,vo2,vo3);

//条件
vo vo4 = new vo("",null,"武汉");

if(vo4.getName() != null && !"".equals(vo4.getName())){
list = list.stream().filter(vo -> vo.getName().equals(vo4.getName()))
.collect(Collectors.toList());
}
if(vo4.getAge() != null){
list = list.stream().filter(vo -> vo.getAge().equals(vo4.getAge()))
.collect(Collectors.toList());
}
if(vo4.getCity() != null && !"".equals(vo4.getCity())){
list = list.stream().filter(vo -> vo.getCity().equals(vo4.getCity()))
.collect(Collectors.toList());
}

list.stream().forEach(vo -> {
System.out.println(vo);
});
}

❽ java 用返回的list去查询数据库,返回list

分析你的逻辑应该如下：
1、查询表1中符合条件的信息，获取一个结果集合1；
2、基于结果集合1循环，检索表2，获取结果集合2。
如此，如果表1、表2间存在直接关联关系（即直接使用结果集合1中的部分信息作为表2查询的条件），那么完全可以在后台将两张表关联查询，这样避免了通过java进行循环，在大数量级情况下会严重占用内存。
如果表1，表2间没有直接的关联关系（即通过循环表1，判断其中条件后按照其它的特定对照值去查询表2），那么仍然建议使用后台表关联查询，及将表1查询的结果集按照不同的条件获取的值转换成对应的映射值后作为一个基准集合，然后将这个集合与表2关联查询即可。具体的sql语句，得根据你使用的数据库和具体场景去编写。

总之，此类情况，完全可以交由数据库搞定，如果使用你现在的逻辑（即查询表1，循环结果集1，然后查询表2，获取结果集2），虽然原则上没有错，但会增加很多内存开销，在大数据量级的情况下，非常容易出现内存溢出的异常，并不作为合理的编码方式。

❾ java中，获取一个list，将list里的数据按不通条件进行分类

你查询的结果是的list里面每个记录应该是 一个Map 或 是一个类（如果有定义的话） 那么你 先新建一个List 再遍历结果list 每条记录 姓名和学期一致的记录放到一个 新Map中，在加到新的List里面 这样就形成你要的数据结构了

❿ java中，如何查询一个list并得到list里面子集合的一条数据。

List list = new ArrayList() ; //你的list
Map map = new HashMap(); //用map存起来新的分组后数据
int k = 0;
for(int i = 0;i<list.size();i+=100){
List newlist = list.subList(i,i+99);
map.put(k, newlist);
k++;

}