[java8 stream流 ]

java8新特性流 相关业务排序使用:

当集合是JSONArray的时候

array = array.stream().sorted(Comparator.comparing(obj -> JSONObject.parseObject(JSON.toJSONString(obj)).getString(orderParamName), Collator.getInstance(Locale.CHINA)))
                        .collect(Collectors.toCollection(JSONArray::new));
 

当集合是对象的时候
字段存在空值的时候需要通过nullsFirst nullsLast 去处理

qqList = qqList.stream().sorted(Comparator.comparing(TbDealerQq::getNickName,Comparator.nullsFirst(String::compareTo))).collect(Collectors.toList());```
 

汉字需要用 Collator.getInstance(Locale.CHINA) 处理

qqList = qqList.stream().sorted(Comparator.comparing(TbDealerQq::getNickName,Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
 

这个是其他博主哪里的   记录一下

List<类> list; 代表某集合
 
//返回 对象集合以类属性一升序排序
 
list.stream().sorted(Comparator.comparing(类::属性一));
 
//返回 对象集合以类属性一降序排序 注意两种写法
 
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序
 
//返回 对象集合以类属性一升序 属性二升序
 
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
 
//返回 对象集合以类属性一降序 属性二升序 注意两种写法
 
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序
 
//返回 对象集合以类属性一降序 属性二降序 注意两种写法
 
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
 
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
 
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
 
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

 

普通排序:

正序:(升序)

list=list.stream().sorted().collect(Collectors.toList());

list.stream().sorted(Comparator.comparing(Student::getAge)) 
 

倒序:

list.stream().sorted(Comparator.reverseOrder())
list.stream().sorted(Comparator.comparing(Student::getAge).reversed())
 

场景二:含空值排序

有时候数据库会有一些错误数据，但是又要求程序不能报错，这怎么办呢？

1.含空值的正序（升序）排序(按创建时间排序)

list=list.stream().sorted(Comparator.comparing(l -> l.getCreateTime(), Comparator.nullsFirst(Date::compareTo).reversed())).collect(Collectors.toList());
 

如果创建时间可能为空就会报错

2.含空值的倒序（降序）排序

nullsFirst：空值放第一位

list=list.stream().sorted(Comparator.comparing(l -> l.getCreateTime(), Comparator.nullsFirst(Date::compareTo).reversed())).collect(Collectors.toList());
 

nullsLast：空值放最后

list=list.stream().sorted(Comparator.comparing(l -> l.getCreateTime(), Comparator.nullsLast(Date::compareTo).reversed())).collect(Collectors.toList());
 

不使用stream:

// 正序
list.sort(Comparator.comparing(Integer::intValue));
 // 倒序
list.sort(Comparator.comparing(Integer::intValue).reversed());
 // 正序
list.sort(Comparator.comparing(Student::getAge));
  // 倒序
list.sort(Comparator.comparing(Student::getAge).reversed());
 
 https://blog.csdn.net/yujing1314/article/details/112177459

[问题集] Collections.sort 无论怎么排序，希望把无效的值排到后边

 @Test
    public void sortTest(){
        List<String> aList = new ArrayList();
        // null -- 代表无效的数值，无论怎么排序，希望把无效的值排到后边
        aList.add("8");
        aList.add("0");
        aList.add("3");
        aList.add("19");
        aList.add(null);
        aList.add("--");
        aList.add(null);
        aList.add("--");
        aList.add("3");
        aList.add("19");

        Collections.sort(aList, (a, b) -> {
            if((a == null || a.equals("--")) && (b == null || b.equals("--"))){
                return 0;
            }

            if(a == null || a.equals("--")){
                return 1;
            }

            if(b == null || b.equals("--")){
                return -1;
            }

            return -new BigDecimal(a).compareTo(new BigDecimal(b));
        });

        log.info(aList + "");
    }
 

当初想实现的逻辑是 对List<Map<String,String>> 格式的数据进行排序   但是数据有间隔 

这里必须满足   id 是要循环的 key 字段 ,  aa 线路合计就是隔开的数据 

偶数下标是要排序的字段  奇数的是隔开的数据

// TODO Auto-generated method stub
List<Map<String, String>> list = new ArrayList<Map<String, String>>();
Map<String, String> map1 = new HashMap<String, String>();
map1.put("id", "线路2");
map1.put("name", "a");
Map<String, String> map2 = new HashMap<String, String>();
map2.put("aa", "线路合计");
map2.put("name", "线路2");
Map<String, String> map3 = new HashMap<String, String>();
map3.put("id", "线路1");
map3.put("name", "f");
Map<String, String> map4 = new HashMap<String, String>();
map4.put("aa", "线路合计");
map4.put("name", "线路1");
Map<String, String> map5 = new HashMap<String, String>();
map5.put("id", "线路3");
map5.put("name", "e");
Map<String, String> map6 = new HashMap<>();
map6.put("aa", "线路合计");
map6.put("name", "线路3");
list.add(map1);
list.add(map2);
list.add(map3);
list.add(map4);
list.add(map5);
list.add(map6);

List<Map<String,Object>> mapList = new ArrayList<>();
for(int i = 0 ; i < list.size() ; i=i+2 ){
    //线路信息;
    Map<String, String> info = list.get(i);
    //集合
    Map<String, String> count = list.get(i + 1);
    String id = info.get("id");
    Map<String, Object> allInfoMap = new HashMap<>();
    allInfoMap.put("id",id);
    allInfoMap.put("info",info);
    allInfoMap.put("count",count);
    mapList.add(allInfoMap);
}

mapList =  mapList.stream().sorted(Comparator.comparing(l->JSON.toJSONString(l.get("id")))).collect(Collectors.toList());

List<Map<String,String>> resultList = new ArrayList<>();
for (Map<String, Object> map : mapList) {
    Map<String,String> info =(Map<String,String>) map.get("info");
    Map<String,String> count =(Map<String,String>) map.get("count");
    resultList.add(info);
    resultList.add(count);
}
System.out.println(JSON.toJSONString(resultList));