场景:现有List<Person>集合,我现要对名字为张三的对象，的描述进行拼接，
得到瘦身版的List<Person> 案例如下:
List<User> pList = Arrays.asList(new User("张三","身高170"),new User("张三","体重130"),new User("张三","年龄23"),new User("李四","身高170"))
要实现得到:
List<User> pList = Arrays.asList(new User("张三","身高170,体重130,年龄23"),new User("李四","身高170"))
具体操作有如下:
先根据姓名分组:用 Collectors.groupingBy
Map<String, List<User>> collect = pList.stream()
.collect(Collectors.groupingBy(User::getDept ));
然后
pList = collect.entrySet().stream()
.map(entry -> {
String key = entry.getKey();
List<User> value = entry.getValue();
String desc = value.stream()
.map(e -> e.getDesc())
.collect(Collectors.toList());
User user = value.get(0);
user.setDesc(desc);
return user;
// 在这里处理键值对
System.out.println("Key: " + key + ", Value: " + value);
}).collect(Collectors.toList());;
sorted()排序:
list.stream().sorted(Comparator.comparing(类::属性一));
// list里面是map的，List<Map<String, Integer>>
list.stream().sorted(Comparator.comparingInt(map -> map.get("key")));
2.2.降序：reversed()和Comparator.reverseOrder()，有区别：
reversed()：先排序（默认升序)，然后降序；
Comparator.reverseOrder()：直接降序排序；
//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一).reversed());
//以属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));
//属性一升序,属性二降序
list.stream().sorted(Comparator.comparing(类::属性一)
.thenComparing(类::属性二,Comparator.reverseOrder()));
//属性一降序,属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,
Comparator.reverseOrder()).thenComparing(类::属性二));
3 Collectors.toMap的使用场景:
3.1List 转 Map<ID, User>
Map<String, User> userMap = users.stream().collect(
Collectors.toMap(
User::getId,
Function.identity(),
(k1, k2) -> k1 //key重复，用第一个
(k1, k2) -> {
if(Objects.equals(k1.getA(),k2.getA() {
k2.setB(k1.getB()+k2.getB());
}
return k2;
}
)
);
3.2List 转 Map<ID, Name>
Map<String, String> idToName = users.stream().collect(
Collectors.toMap(
User::getId,
User::getName
)
);
- 将集合类型进行一个转换<映射>（map）
// 1.将对象包装为返回类
List<User> dataList = UserMapper.selectList(null);
List<UserVO> voList = dataList.stream().map(data -> {
return new UserVO(
data.getId(),
data.getName()
);
}).collect(Collectors.toList());
// 2.将对象属性抽取出来返回一个单独的集合
List<Integer> idList = dataList.stream().map(data -> data.getId()).collect(Collectors.toList());
// 1.是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(x -> x < 6);
// 2.获取String集合中最长的元素
List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
Optional<String> max = list.stream().max(Comparator.comparing(String::length));
System.out.println("最长的字符串：" + max.get());
输出：
最长的字符串：weoujgsd
// 3.获取Integer集合中的最大值
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
// 自然排序
Optional<Integer> max = list.stream().max(Integer::compareTo);
// 自定义排序
Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
System.out.println("自然排序的最大值：" + max.get());
System.out.println("自定义排序的最大值：" + max2.get());
输出：
自然排序的最大值：11
自定义排序的最大值：11
// 4.统计计数
long count = list.stream().filter(x -> x > 6).count();
// 5.将两个字符数组合并成一个新的字符数组
List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
// flatMap使用方法：对于调用flatmap的流的每一个元素，执行flatmap入参中的函数式方法，返回一个stream流与之前的合并
List<String> listNew = list.stream().flatMap(s -> {
// 将每个元素转换成一个stream
String[] split = s.split(",");
Stream<String> s2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());
// 6.归约的用法，reduce
// 求和方式
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
// 求最大值写法2
Integer max2 = list.stream().reduce(1, Integer::max);
// 7.分组后统计计数 (字符串集合)
Map<String, Long> map = list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
/*
anyMatch：判断的条件里，任意一个元素成功，返回true
allMatch：判断条件里的元素，所有的都是，返回true
noneMatch：与allMatch相反，判断条件里的元素，所有的都不是，返回true
count方法，跟List接口中的 .size() 一样，返回的都是这个集合流的元素的长度，不同的是，流是集合的一个高级工厂，中间操作是工厂里的每一道工序，我们对这个流操作完成后，可以进行元素的数量的和；
*/
list.stream().anyMatch(c-> RoleEnum.ZREO.getValue().equals(c));
// 根据userId去重，返回User集合
list.stream().collect(
Collectors.collectingAndThen(
Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getUserId))),
ArrayList::new
)
);
// 查找年龄最高的人
String userName = list.stream().collect(
Collectors.collectingAndThen(
Collectors.maxBy(Comparator.comparing(User::getAge)),
(Optional<User> user) -> user.map(User::getUserName).orElse(null)
)
);
// 计算年龄平均值
Double avgAge = list.stream().collect(
Collectors.collectingAndThen(
Collectors.averagingDouble(User::getAge),
Double::doubleValue
)
);
