Java开发中集合 Stream常用操作总结

1. List 转成 新List

// 查询到一个实体列表，转成一个定制的VO列表
List<RiskIdentifyLibEntity> libList = ....
List<DangerTypeTreeVo> collect = dangerTypeEntityList.stream().map(d -> {
    DangerTypeTreeVo dangerTypeTreeVo = new DangerTypeTreeVo();
    BeanUtils.copyProperties(d, dangerTypeTreeVo);
    return dangerTypeTreeVo;
}).collect(Collectors.toList());

// 提取实体列表某字段列表
List<String> stationList = usersEntityList.stream().map(UsersEntity::getStationId).collect(Collectors.toList());
List<String> guideNames = guideList.stream().map(DangerCheckGuideEntity::getGuideName).collect(Collectors.toList());
// 筛选员工中工资高于8000的人，并形成新的集合。
List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName)
    .collect(Collectors.toList());

2. 过滤筛选

// 过滤id为空的结果
libList =  libList.stream().filter(o -> StringUtils.isNotBlank(o.getId())).collect(Collectors.toList());

List<String> permission=permissionTree.stream().map(Ztree::getType).filter(string -> StrUtil.isNotEmpty(string)).collect(Collectors.toList());

// 去重
deleteList = deleteList.stream().distinct().collect(Collectors.toList());

3. List 转 Map

按某字段分组(按条件、求和等结合)

/**
*  按 (key ： 名字) 构建map
*  key必须是唯一的，不然会报错 Java.lang.IllegalStateException:Duplicate key
*  要在toMap方法中指定当key冲突时key的选择。 Function.identity(), (key1, key2) -> key2 (这里是选择第二个key覆盖第一个key)
*/
Map<String, String> userMap = usersList.stream().collect(Collectors.toMap(UsersEntity::getId, UsersEntity::getUserName));


// 这里是选择第一个key覆盖第二个key
Map<String, TreeVO> treeMap = list.stream().collect(Collectors.toMap(TreeVO::getId, a -> a, (k1, k2) -> k1));

// List<实体> ---> Map<实体id,实体> (id需唯一)
Map<String, DangerCheckRecordEntity> recordsMap = recordEntities.stream().collect(Collectors.toMap(DangerCheckRecordEntity::getOperatorId,
                        DangerCheckRecordEntity -> DangerCheckRecordEntity));

// 检查记录按 (taskId : 数量) 构建map
Map<String, Long> map = records.stream().collect(Collectors.groupingBy(DangerCheckRecordEntity::getTaskId, Collectors.counting()));

// 将员工按薪资是否高于8000分组
Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));

// 将员工按性别分组
Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));

Map再嵌套Map

// 返回 Map<String, Map<Integer, Person>>
Map<String, Map<Integer, Person>> collect = personList.stream().collect(Collectors.toMap(Person::getName, p -> {
            Map<Integer, Person> map = new HashMap<>();
            map.put(p.getAge(), p);
            return map;
        }));

// 将员工先按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));


// 多级分组
Map<String, Map<String, List<Product>>> prodMap= prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.groupingBy(item -> {
	if(item.getNum() < 3) {
		return "3";
	}else {
		return "other";
	}
})));
//结果：{"啤酒":{"other":[{"category":"啤酒","id":4,"name":"青岛啤酒","num":3,"price":10},{"category":"啤酒","id":5,"name":"百威啤酒","num":10,"price":15}]},"零食":{"other":[{"category":"零食","id":3,"name":"月饼","num":3,"price":30}],"3":[{"category":"零食","id":1,"name":"面包","num":1,"price":15.5},{"category":"零食","id":2,"name":"饼干","num":2,"price":20}]}}

4. 统计

// 已启用的数据量
long enableCount = list.stream().filter(o -> o.getHasStatus() == 0).count();

// 已锁定的数据量
long lockCount = list.stream().filter(o -> o.getHasStatus() == 2).count();

 // 求总数
Long count = personList.stream().collect(Collectors.counting());

// 求总数
Integer count = hiddenItemStandardCounts.stream().mapToInt(item -> item).sum();

// 求工资之和方式1：
Integer sumSalary1 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), (sum1, sum2) -> sum1 + sum2);

// 求工资之和方式2：
Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);

// 求工资之和3
Integer sumSalary3 = personList.stream().collect(Collectors.summingInt(Person::getSalary));

// 求平均工资
Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));

// 求最高工资
Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));

// 一次性统计所有信息
// 结果示例：DoubleSummaryStatistics{count=3, sum=23700.000000,min=7000.000000, average=7900.000000, max=8900.000000}
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

5. 排序

//由于hashmap无序，所以在排序放入LinkedHashMap里(key升序)
Map<String, Long> sortMap = new LinkedHashMap<>();
map.entrySet().stream().sorted(Map.Entry.comparingByKey()).
    forEachOrdered(e -> sortMap.put(e.getKey(), e.getValue()));
System.out.println(sortMap);

//获取排序后map的key集合
List<String> keys = new LinkedList<>();
sortMap.entrySet().stream().forEachOrdered(e -> keys.add(e.getKey()));
System.out.println(keys);

//获取排序后map的value集合
List<Long> values = new LinkedList<>();
sortMap.entrySet().stream().forEachOrdered(e -> values.add(e.getValue()));
System.out.println(values);

完整示例

public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
 
  personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
  personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
  personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
  personList.add(new Person("Lily", 8800, 26, "male", "New York"));
  personList.add(new Person("Alisa", 9000, 26, "female", "New York"));
 
  // 按工资增序排序
  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).reversed())
    .map(Person::getName).collect(Collectors.toList());
  // 先按工资再按年龄自定义排序（从大到小）
  List<String> newList4 = personList.stream().sorted((p1, p2) -> {
   if (p1.getSalary() == p2.getSalary()) {
    return p2.getAge() - p1.getAge();
   } else {
    return p2.getSalary() - p1.getSalary();
   }
  }).map(Person::getName).collect(Collectors.toList());
 
  System.out.println("按工资自然排序：" + newList);
  System.out.println("按工资降序排序：" + newList2);
  System.out.println("先按工资再按年龄自然排序：" + newList3);
  System.out.println("先按工资再按年龄自定义降序排序：" + newList4);
 }
}

结果：
按工资自然排序：[Lily, Tom, Sherry, Jack, Alisa]
按工资降序排序：[Sherry, Jack, Alisa,Tom, Lily]
先按工资再按年龄自然排序：[Sherry, Jack, Alisa, Tom, Lily]
先按工资再按年龄自定义降序排序：[Alisa, Jack, Sherry, Tom, Lily]

6. 字符拼接

public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("Tom", 8900, 23, "male", "New York"));
  personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
  personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
 
  String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
  System.out.println("所有员工的姓名：" + names);
  List<String> list = Arrays.asList("A", "B", "C");
  String string = list.stream().collect(Collectors.joining("-"));
  System.out.println("拼接后的字符串：" + string);
 }
}

结果：
所有员工的姓名：Tom,Jack,Lily
拼接后的字符串：A-B-C