Java stream常用方法

1，提取

//抽取list集合字段1，并去重
List<Long> projectIds = projectList.stream().map(ProjectEntity::getProjectId).distinct().collect(Collectors.toList());
Set<Long> projectIds = projectList.stream().map(ProjectEntity::getProjectId).collect(Collectors.toSet());

2，类型转换list–map

//抽取list集合字段1，字段2，转map
Map<Long, String> projectMap = projectList.stream().collect(Collectors.toMap(ProjectEntity::getId, ProjectEntity::getName));

//当转换的map类型的key存在重复值，就会报错，修改为以下（当key重复时，选择第一个）
Map<String, String> projectMap = personList.stream().collect(Collectors.toMap(Person::getCode, Person::getName, (o, n) -> o));

Map<String, Person> projectMap = personList.stream().collect(Collectors.toMap(Person::getCode, v->v, (o, n) -> o));

3，分组

//根据list字段1分组
Map<Long, ProjectEntity> map = projectList.stream().collect(Collectors.toMap(k -> k.getId(), v -> v));
//状态是否为大于1进行分组
Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getState() > 1));
//按编码分组
Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getCode));
//先按编码，再按状态分组
Map<String, Map<Integer, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getCode, Collectors.groupingBy(Person::getState)));
//查询考同一分数的学生数量（按分数分组，计数）
Map<String, Long> collect = list.stream().collect(Collectors.groupingBy(Student::getGrade, Collectors.counting()));

4，连接合并

//list字段1连接
String names = personList.stream().map(x->x.getName()).collect(Collectors.joining("和"));
String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
//list转为string，使用;拼接
List<String> contents = new ArrayList<>();
String content = contents.stream().collect(Collectors.joining(";"));
// concat:合并两个流 distinct：去重
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());

5，排序

//（注意：多个字段排序的时候，要么全升序，要么全降序）
// 按工资升序排序（自然排序）。抽取姓名字段
List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
        .collect(Collectors.toList());
// 按工资倒序排序。抽取姓名字段
List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
        .map(Person::getName).collect(Collectors.toList());
// 先按工资升序再按年龄升序排序。抽取姓名字段
List<String> newList3 = personList.stream()
        .sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getState)).map(Person::getName)
        .collect(Collectors.toList());

6，聚合函数

Optional<Integer> sum = personList.stream().map(Person::getState).reduce(Integer::sum);
Optional<Integer> max = personList.stream().map(Person::getState).reduce(Integer::max);
System.out.println(sum.get());
System.out.println(max.get());
//求和
List<BigDecimal> list = Arrays.asList(BigDecimal.ONE, BigDecimal.ONE, BigDecimal.TEN);
BigDecimal reduce = list.stream().reduce(BigDecimal.ZERO, BigDecimal::add);//12
//求和
List<Integer> list = Arrays.asList(1, 2, 3, 4);
Optional<Integer> reduce = list.stream().reduce((x,y) -> x+ y);

7，比较

//值大小比较
List<String> list = Arrays.asList("zhangsan", "lisi", "wangwu", "sunliu");
Optional<String> max = list.stream().max(String::compareTo);
System.out.println(max.get());

List<Integer> list = Arrays.asList(1, 17, 27, 7);
Optional<Integer> max = list.stream().max(Integer::compareTo);
System.out.println(max.get());

//值属性比较
List<String> list = Arrays.asList("zhangsan", "lisi", "wangwu", "sunliu");
Comparator<? super String> comparator = Comparator.comparing(String::length);
Optional<String> max = list.stream().max(comparator);
System.out.println(max.get());

8，匹配过滤

List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 遍历输出符合条件的元素
List<Integer> list1 = list.stream().filter(x -> x > 6).collect(Collectors.toList());
// 匹配第一个
Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
// 是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(x -> x < 6);
// 是否所有数据都满足匹配
boolean allMatchCheck = list.stream().allMatch(e -> (CheckStatusEnum.CHECK_PASS.equals(e.getCheckStatus()) || StatusEnum.PASS.equals(e.getStatus())));
// 匹配第一个
Optional<Person> findFirst = personList.stream().filter(x -> x.getSalary()>3000).findFirst();
System.out.println(findFirst.get());
// 匹配任意（适用于并行流）
Optional<Person> findAny = personList.parallelStream().filter(x -> x.getSalary()>3000).findAny();
System.out.println(findAny.get());
// 是否包含符合特定条件的元素
boolean anyMatch = personList.stream().anyMatch(x ->x.getSalary()>3000);
System.out.println(anyMatch);

List<Integer> findFirst = personList.stream().filter(x -> x.getSalary()>3000).map(Person::getSalary).collect(Collectors.toList());

9，其他应用

//list按照操作人分组，提取每个分组内时间最大的记录
Map<Long, SysLogDTO> logMap = logList.parallelStream().filter(Objects::nonNull).
 collect(Collectors.groupingBy(a -> a.getOperatorId(),
 Collectors.collectingAndThen(Collectors.reducing((c1, c2) -> (c1.getOperateTime().getTime() > c2.getOperateTime().getTime()) ? c1 : c2), Optional::get)));


//寻找两个list的交集数据（两个对象所有字段数据一致，才算一个交集）
 List<Person> wList = new ArrayList<Person>();
 Person projectChart1 = new Person();
 projectChart1.setName("li");
 projectChart1.setCode("X0001");
 projectChart1.setState(2);
 projectChart1.setSalary(3000);
 wList.add(projectChart1);
 List<Person> common = personList.stream().filter(item -> wList.contains(item)).collect(Collectors.toList());
 System.out.println(common);


//没有匹配到该数据，移除出去
if (ToolUtil.isEmpty(matchList) || matchList.size() == 0) {
    personList.remove(taskEntity);
}

//将listA复制给listB，根据属性名
//注意：
//1，BeanUtils.copyProperties只支持单个对象copy
//2，copy的对象必须保持属性名和类型一致才可，数量不做要求
 List<TaskEntity> listB = new LinkedList<>();
 listA.stream().forEach(
       taskEntity -> {
           TaskEntity task = new TaskEntity();
           BeanUtils.copyProperties(taskEntity,task);
           listB.add(task);
       }
 );

10，参考连接

https://blog.csdn.net/qq_45228323/article/details/121328790

Java 8 stream的详细用法

Java 8 Stream常用方法学习