#自然序排序一个list
list.stream().sorted() 
 
#自然序逆序元素，使用Comparator 提供的reverseOrder() 方法
list.stream().sorted(Comparator.reverseOrder()) 
 
# 使用Comparator 来排序一个list
list.stream().sorted(Comparator.comparing(Student::getAge)) 
 
# 颠倒使用Comparator 来排序一个list的顺序，使用Comparator 提供的reverseOrder() 方法
list.stream().sorted(Comparator.comparing(Student::getAge).reversed())

List对象集合按时间倒序排序

list = list.stream().sorted(Comparator.comparing(实体::排序字段).reversed()).collect(Collectors.toList());

List<Map<String, Object>> 对象如何排序？

List<Map<String, Object>> list = new ArrayList<>();
Map<String, Object> map = new HashMap<>();
map.put("id",1);
map.put("num", 2);
list.add(map);
map = new HashMap<>();
map.put("id",3);
map.put("num", 4);
list.add(map);
map = new HashMap<>();
map.put("id",2);
map.put("num", 5);
list.add(map);

如果是Java8的话，简单粗暴
    //升序
    list.sort(Comparator.comparingInt(o -> Integer.parseInt(o.get("id").toString())));

java8的lambda表达式提供了一些方便list操作的方法，主要涵盖分组、过滤、求和、最值、排序、去重。跟之前的传统写法对比，能少写不少代码。

新建实体类

package com.vvvtimes.vo;

import java.math.BigDecimal;
import java.util.Date;

public class User {

private Long id;
 
//姓名
private String name;
 
//年龄
private int age;
 
//工号
private String jobNumber;
 
//性别
private String sex;
 
//入职日期
private Date entryDate;
 
//家庭成员数量
private BigDecimal familyMemberQuantity;
 
public Long getId() {
    return id;
}
 
public void setId(Long id) {
    this.id = id;
}
 
public String getName() {
    return name;
}
 
public void setName(String name) {
    this.name = name;
}
 
public int getAge() {
    return age;
}
 
public void setAge(int age) {
    this.age = age;
}
 
public String getJobNumber() {
    return jobNumber;
}
 
public void setJobNumber(String jobNumber) {
    this.jobNumber = jobNumber;
}
 
public String getSex() {
    return sex;
}
 
public void setSex(String sex) {
    this.sex = sex;
}
 
public Date getEntryDate() {
    return entryDate;
}
 
public void setEntryDate(Date entryDate) {
    this.entryDate = entryDate;
}
 
public BigDecimal getFamilyMemberQuantity() {
    return familyMemberQuantity;
}
 
public void setFamilyMemberQuantity(BigDecimal familyMemberQuantity) {
    this.familyMemberQuantity = familyMemberQuantity;
}

}

1.分组

通过groupingBy可以分组指定字段

    //分组
    Map<String, List<User>> groupBySex = userList.stream().collect(Collectors.groupingBy(User::getSex));
    //遍历分组
    for (Map.Entry<String, List<User>> entryUser : groupBySex.entrySet()) {
        String key = entryUser.getKey();
        List<User> entryUserList = entryUser.getValue();
    }

上门的分组存在key空值安全问题，需要做过滤或封装处理

用Optional封装使用中会报No value present

//分组添加累计
Map<Optional, List> groupMap = list.stream().collect(Collectors.groupingBy(x -> Optional.ofNullable(x.getReviewerGroupId())));
//遍历分组
for (Map.Entry<Optional, List> entryGroup : groupMap.entrySet()) {
Optional key = entryGroup.getKey();
Long groupId = key.get();
List entryGroupList = entryGroup.getValue();
}
正确使用方法如下，自定义groupingBy_WithNullKeys

/** Like Collectors.groupingBy, but accepts null keys. */
public static <T, A> Collector<T, ?, Map<A, List>>
groupingBy_WithNullKeys(Function<? super T, ? extends A> classifier) {
return Collectors.toMap(
classifier,
Collections::singletonList,
(List oldList, List newEl) -> {
List newList = new ArrayList<>(oldList.size() + 1);
newList.addAll(oldList);
newList.addAll(newEl);
return newList;
});
}
然后调用

Map<Long, List> groupMap = list.stream().collect(groupingBy_WithNullKeys(x -> x.getReviewerGroupId()));
多字段分组

    Function<WarehouseReceiptLineBatch, List<Object>> compositeKey = wlb ->
            Arrays.<Object>asList(wlb.getWarehouseReceiptLineId(), wlb.getWarehouseAreaId(), wlb.getWarehouseLocationId());
    Map<Object, List<WarehouseReceiptLineBatch>> map =
            warehouseReceiptLineBatchList.stream().collect(Collectors.groupingBy(compositeKey, Collectors.toList()));
    //遍历分组
    for (Map.Entry<Object, List<WarehouseReceiptLineBatch>> entryUser : map.entrySet()) {
        List<Object> key = (List<Object>) entryUser.getKey();
        List<WarehouseReceiptLineBatch> entryUserList = entryUser.getValue();
        Long warehouseReceiptLineId = (Long) key.get(0);
        Long warehouseAreaId = (Long) key.get(1);
        Long warehouseLocationId = (Long) key.get(2);
 
    }

2.过滤

通过filter方法可以过滤某些条件

    //过滤
    //排除掉工号为201901的用户
    List<User> userCommonList = userList.stream().filter(a -> !a.getJobNumber().equals("201901")).collect(Collectors.toList());

3.求和

分基本类型和大数类型求和，基本类型先mapToInt，然后调用sum方法，大数类型使用reduce调用BigDecimal::add方法

    //求和
    //基本类型
    int sumAge = userList.stream().mapToInt(User::getAge).sum();
    //BigDecimal求和
    BigDecimal totalQuantity = userList.stream().map(User::getFamilyMemberQuantity).reduce(BigDecimal.ZERO, BigDecimal::add);

上面的求和不能过滤bigDecimal对象为null的情况，可能会报空指针，这种情况，我们可以用filter方法过滤，或者重写求和方法

重写求和方法

package com.vvvtimes.util;

import java.math.BigDecimal;

public class BigDecimalUtils {

public static BigDecimal ifNullSet0(BigDecimal in) {
    if (in != null) {
        return in;
    }
    return BigDecimal.ZERO;
}
 
public static BigDecimal sum(BigDecimal ...in){
    BigDecimal result = BigDecimal.ZERO;
    for (int i = 0; i < in.length; i++){
        result = result.add(ifNullSet0(in[i]));
    }
    return result;
}

}

使用重写的方法

BigDecimal totalQuantity2 = userList.stream().map(User::getFamilyMemberQuantity).reduce(BigDecimal.ZERO, BigDecimalUtils::sum);
判断对象空

stream.filter(x -> x!=null)
stream.filter(Objects::nonNull)
判断字段空

stream.filter(x -> x.getDateTime()!=null)
4.最值

求最小与最大，使用min max方法

    //最小
    Date minEntryDate = userList.stream().map(User::getEntryDate).min(Date::compareTo).get();
 
    //最大
    Date maxEntryDate = userList.stream().map(User::getEntryDate).max(Date::compareTo).get();

有时候我们需要知道最大最小对应的这个对象，我们可以通过如下方法获取

Comparator comparator = Comparator.comparing(LeasingBusinessContract::getLeaseEndDate);
LeasingBusinessContract maxObject = leasingBusinessContractList.stream().max(comparator).get();
5.List 转map

     /**
     * List -> Map
     * 需要注意的是：
     * toMap 如果集合对象有重复的key，会报错Duplicate key ....
     *  user1,user2的id都为1。
     *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
     */
    Map<Long, User> userMap = userList.stream().collect(Collectors.toMap(User::getId, a -> a,(k1,k2)->k1));

list转map的时候有时候会将date类型作为key，实际情况中使用string的多，我们可以将某个字段转成string

Map<String, WorkCenterLoadVo> workCenterMap = list.stream().collect(Collectors.toMap(key->DateFormatUtils.format(key.getDate(), “yyyy-MM-dd”), a -> a,(k1,k2)->k1));
list转map有时候会用到多字段key的map结构，除了常用的key用字符串连接，也可以使用apache commons的多字段key形式的map结构MultiKeyMap

6.排序

可通过Sort对单字段多字段排序

    //排序
    //单字段排序，根据id排序
    userList.sort(Comparator.comparing(User::getId));
    //多字段排序，根据id，年龄排序
    userList.sort(Comparator.comparing(User::getId).thenComparing(User::getAge));

实际上这个写法存在空值安全问题，建议改成

userList.sort(Comparator.comparing(User::getId,Comparator.nullsLast(Comparator.naturalOrder())).thenComparing(User::getAge,Comparator.nullsLast(Comparator.naturalOrder())));
7.去重

可通过distinct方法进行去重

    //去重
    List<Long> idList = new ArrayList<Long>();
    idList.add(1L);
    idList.add(1L);
    idList.add(2L);
    List<Long> distinctIdList = idList.stream().distinct().collect(Collectors.toList());
  
  针对List<Map<String, Object>> 某个属性进行去重   例如 time
    List<Map<String, Object>> list= new ArrayList<>();
        for (int i =0 ; i<5; i++){
            HashMap<String, Object> map = new HashMap<>();
            map.put("time","2023-04-26");
            map.put("user","sb");
            list.add(map);
            HashMap<String, Object> map2 = new HashMap<>();
            map2.put("time","2023-04-25");
            map2.put("user","sb0");
            list.add(map2);
        }
        HashMap<String, Object> map = new HashMap<>();
        map.put("time","2023-04-27");
        map.put("user","sb1");
        list.add(map);
        HashMap<String, Object> map1 = new HashMap<>();
        map1.put("time","2023-04-28");
        map1.put("user","sb2");
        list.add(map1);
        List<Object> time = list.stream().map(a -> a.get("time")).distinct().collect(Collectors.toList());
        System.out.println(time);

针对属性去重

List entryDetailsBatchDistinctBatchIdList = entryDetailsBatchList.stream().filter(distinctByKey(b -> b.getMaterialBatchNumberId())).collect(Collectors.toList());

//distinctByKey自己定义
public static Predicate distinctByKey(Function<? super T, Object> keyExtractor) {
Map<Object, Boolean> seen = new ConcurrentHashMap<>();
return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
8.获取list某个字段组装新list

    //获取list对象的某个字段组装成新list
    List<Long> userIdList = userList.stream().map(a -> a.getId()).collect(Collectors.toList());

9.批量设置list列表字段为同一个值

addList.stream().forEach(a -> a.setDelFlag(“0”));
10.不同实体的list拷贝

List timePeriodDateList1 = calendarModelVoList.stream().map(p->{TimePeriodDate e = new TimePeriodDate(); e.setStartDate(p.getBegin());e.setEndDate(p.getEnd()); return e;}).collect(Collectors.toList());