Java lambda Stream List过滤筛选、排序、分组（Java进阶）

重要！重要！重要！用起来很方便，舍弃for循环查找符合的对象、排序、分组
将压力交给服务器，减少数据查询次数，提升查询速度
建议收藏

最近在找工作，Java前后端全站工程师一枚，有合适的请帮博主推荐一下 有项目的也可以联系我，感谢感谢 博主在北京 2023-07-04 发 V：y393016244

返回集合

在List中筛选出Map中“jzqklx”的值等于“abc”的Map，返回List集合
d为dayFwsl集合中的Map对象
List中可以是任意对象，如List判断条件可以.fiter(d->StringUtils.equals(d.getType(), “01”))

List<Map<String, Object>> dayFwsl =  new ArrayList<>();
List<Map<String, Object>> jzqklx1 = dayFwsl.stream().filter(d -> StringUtils.equals(d.get("jzqklx") + "", "abc"))
	.collect(Collectors.toList());

也可以这么写

List<Map<String, Object>> dayFwsl =  new ArrayList<>();
List<Map<String, Object>> jzqklx1 = dayFwsl.stream().filter(d -> {
	//任意代码，return 一个Boolean 值即可
	return StringUtils.equals(d.get("jzqklx") + "", "abc");
}).collect(Collectors.toList());

返回单个对象

返回单个对象，如果不存在默认返回null

List<Map<String, Object>> dayFwsl =  new ArrayList<>();
Map<String, Object> jzqklx2 = dayFwsl.stream().filter(d -> 
	StringUtils.equals(d.get("jzqklx") + "", dd.getDictValue())).findAny().orElse(null);

判断集合中是否包含某个元素

返回List对象中的判断

//其中有一个对象的jzqklx等于222则返回true
List<Map<String, Object>> dayFwsl =  new ArrayList<>();
boolean b = dayFwsl.stream().anyMatch(d->d.get("jzqklx").equals("222"));

//所有对象的jzqklx等于222则返回true
List<Map<String, Object>> dayFwsl =  new ArrayList<>();
boolean b = dayFwsl.stream().allMatch(d->d.get("jzqklx").equals("222"));

//所有对象的jzqklx不等于222则返回true
List<Map<String, Object>> dayFwsl =  new ArrayList<>();
boolean b = dayFwsl.stream().noneMatch(d->d.get("jzqklx").equals("222"));

//可以写成复杂条件
boolean b = dayFwsl.stream().anyMatch(d->{
	if(d.get("jzqklx").equals("222")&&d.get("abc").equals("333")){
		return true;
	}else{
		return false;
	}
});

排序、分组、自定义分组

//Map排序
mapList.sort(Comparator.comparing(d->d.get(“value”)));
//对象排序
mapList.sort(Comparator.comparing(Student::getFraction));
//对象排序 倒序（应该对象类型可以，Map类型不行）
mapList.sort(Comparator.comparing(Student::getFraction).reversed());
//Map分组
Map<Object, List<Map<String, Integer>>> mList2 = mapList.stream().collect(Collectors.groupingBy(d -> d.get(“value”)));
//对象分组
Map<Object, List<Map<String, Integer>>> mList2 = mapList.stream().collect(Collectors.groupingBy(Student::getFraction));

public static void main(String[] args) {
    List<Map<String,Integer>> mapList=new ArrayList<>();
    for (int i=0;i<100;i++){
        Map<String,Integer> map=new HashMap<>();
        map.put("key",i);//生成100内的随机数
        map.put("value",(int)(Math.random()*(100)));//生成100内的随机数
        mapList.add(map);
    }

    //以value排序
    mapList.sort(Comparator.comparing(d->d.get("value")));
    System.out.println("mapList排序："+JSON.toJSONString(mapList));

    //自定义分组的key
    Map<Object, List<Map<String, Integer>>> mList = mapList.stream().collect(Collectors.groupingBy(d -> {
        if(d.get("value")<20){
            return "小于20";
        }else if (d.get("value")<40){
            return "大于20，小于40";
        }else if (d.get("value")<60){
            return "大于40，小于60";
        }else if (d.get("value")<80){
            return "大于60，小于80";
        }else{
            return "大于80";
        }
    }));

    System.out.println(JSON.toJSONString(mList));
    //以value分组
    Map<Object, List<Map<String, Integer>>> mList2 = mapList.stream()
    	.collect(Collectors.groupingBy(d -> d.get("value")));
    System.out.println(JSON.toJSONString(mList2));
}

List Map对象使用Collections排序

List<Map<String,Integer>> mapList=new ArrayList<>();
//排序
Collections.sort(list, (map1, map2) -> {
    Integer value1 = (Integer) map1.get("value");
    Integer value2 = (Integer) map2.get("value");
    //根据比较大小进行排序，可调整正序或倒序
    return value2.compareTo(value1);
});

List Map对象求和

int ldrkCount = mapListLdrys.stream().mapToInt(d->Integer.parseInt(d.get("count")+"")).sum();

java 反转list

List list = Arrays.asList(1,2,3,4,5);
Collections.reverse(list);
System.out.println(list);

也可以使用Stream API实现反转：

List list = Arrays.asList(1,2,3,4,5);
List reversedList = list.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());
System.out.println(reversedList);