文章目录
- stream求和BigDecimal
- Stream将List转换为Map，使用Collectors.toMap方法进行转换。
- List拼接字符串
- set转list
- stream的groupingBy分组
- 按性别单级分组
- 多层级分组
- 对List＜map＞分组
- 按子分组
- 求和：按分类统计订单数（一个订单算一个）
- 求和：按分类统计购买的产品数量（一个订单购买了多个）
- 筛选：按类型筛选出购买数量最大的订单
- 分类组合：按类型分组获取产品名称合并的Set集合
stream求和BigDecimal
BigDecimal result2 = userList.stream()
// 将user对象的mongey取出来map为Bigdecimal
.map(User::getMoney)
// 使用reduce聚合函数,实现累加器
.reduce(BigDecimal.ZERO,BigDecimal::add);Stream将List转换为Map，使用Collectors.toMap方法进行转换。
Stream将List转为Map,Set汇总拼接key以及分组groupingBy用法
1、指定key-value，value是对象中的某个属性值。
Map<Integer,String> userMap1 = userList.stream().collect(Collectors.toMap(User::getId,User::getName));
2、指定key-value，value是对象本身，User->User 是一个返回本身的lambda表达式
Map<Integer,User> userMap2 = userList.stream().collect(Collectors.toMap(User::getId,User->User));
3、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身
Map<Integer,User> userMap3 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));
4、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身，key 冲突的解决办法，这里选择第二个key覆盖第一个key。
Map<Integer,User> userMap4 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(),(key1,key2)->key2));
5、拼接key->Map
Map<String, Parts> partsMap = synList.stream().collect(Collectors.toMap(k -> k.getOe()+k.getOeId()+k.getPartGroupId()+k.getStdPartId()+k.getBrandCode(), part -> part));
6.提取部门ID集合（Set）
Set deptIds = users.stream().map(User::getDeptId).collect(Collectors.toSet());
List拼接字符串
String ids = UserList.map(e->e.getId()).collect(Collectors.joining(“‘,’”));
提取部门ID集合（List）并去重
List deptIds = users.stream().map(User::getDeptId).distinct().collect(Collectors.toList());
set转list
使用构造函数：
Set<Integer> set = new HashSet<>();
// 添加元素到set
List<Integer> list1 = new ArrayList<>(set);使用addAll()方法
Set<Integer> set = new HashSet<>();
// 添加元素到set
List<Integer> list2 = new ArrayList<>();
list2.addAll(set);stream的groupingBy分组
- 单层级分组 ： 单个属性分组
- 多层级分组 ：分组中带有子分组
- 按子组收集数据
public Product(Long id, Integer num, BigDecimal price, String name, String category) {
this.id = id;
this.num = num;
this.price = price;
this.name = name;
this.category = category;
}
Product prod1 = new Product(1L, 1, new BigDecimal("15.5"), "面包", "零食");
Product prod2 = new Product(2L, 2, new BigDecimal("20"), "饼干", "零食");
Product prod3 = new Product(3L, 3, new BigDecimal("30"), "月饼", "零食");
Product prod4 = new Product(4L, 3, new BigDecimal("10"), "青岛啤酒", "啤酒");
Product prod5 = new Product(5L, 10, new BigDecimal("15"), "百威啤酒", "啤酒");
List<Product> prodList = Lists.newArrayList(prod1, prod2, prod3, prod4, prod5);按性别单级分组
//将列表数据按category进行分组
Map<String, List<Product>> categoryMap = prodList.parallelStream()
.collect(Collectors.groupingBy(Product::getCategory));
//使用LinkedHashMap，可以保证分组后顺序不变
Map<String, List<Product>> categoryMap = prodList.parallelStream()
.collect(Collectors.groupingBy(Product::getCategory, LinkedHashMap::new, Collectors.toList()));多层级分组
我们可以使用一个由双参数版本的Collectors.groupingBy工厂方法创 建的收集器，它除了普通的分类函数之外，还可以接受collector类型的第二个参数。那么要进 行二级分组的话，我们可以把一个内层groupingBy传递给外层groupingBy，并定义一个为流 中项目分类的二级标准。
按类别分组，类别分组内部按num>3分组
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
}
]
},
"零食": {
"3": [
{
"category": "零食",
"id": 1,
"name": "面包",
"num": 1,
"price": 15.5
},
{
"category": "零食",
"id": 2,
"name": "饼干",
"num": 2,
"price": 20
}
],
"other": [
{
"category": "零食",
"id": 3,
"name": "月饼",
"num": 3,
"price": 30
}
]
}
}对List＜map＞分组
id | name |
1 | zhangsan |
1 | zhangsan11 |
2 | zhangsan2 |
2 | zhangsan222 |
public static void main(String[] args) {
List<Map<String,Object>> list=new ArrayList<>();
Map<String,Object> map=new HashMap<>();
map.put("id",1);
map.put("name","zhangsan");
list.add(map);
Map<String,Object> map2=new HashMap<>();
map2.put("id",2);
map2.put("name","wanger");
list.add(map2);
Map<String,Object> map3=new HashMap<>();
map3.put("id",4);
map3.put("name","zhangsan");
list.add(map3);
Map<String,Object> map4=new HashMap<>();
map4.put("id",4);
map4.put("name","lisi");
list.add(map4);
Map<Integer, List<Map<String, Object>>> id = list.stream().collect(Collectors.groupingBy(item -> {
return (int)item.get("id");
}));
id.forEach((k,v)->{
System.err.println("===========");
System.err.println("k的值:"+k);
System.err.println("v的值:");
v.forEach(System.err::println);
});
}
分组结果：
[
1:[
{id:1,name:zhagnhan},{id:1,name:zhagnhan111}
],
2:[
{id:2,name:zhagnhan2},{id:2,name:zhagnhan222}
]
]按子分组
求和：按分类统计订单数（一个订单算一个）
Map<String, Long> prodMap =
prodList.stream().collect(Collectors.groupingBy(Product::getCategory,
Collectors.counting()));
分组结果：
{
"啤酒": 2,
"零食": 3
}求和：按分类统计购买的产品数量（一个订单购买了多个）
Map<String, Integer> prodMap =
prodList.stream().collect(Collectors.groupingBy(Product::getCategory,
Collectors.summingInt(Product::getNum)));
分组结果：
{
"啤酒": 13,
"零食": 6
}筛选：按类型筛选出购买数量最大的订单
把收集器的结果转换为另一种类型
Map<String, Product> prodMap =
prodList.stream().collect(Collectors.groupingBy(Product::getCategory,
Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingInt(Product::getNum)),
Optional::get)));
分组结果：
{
"啤酒": {
"category": "啤酒",
"id": 5,
"name": "百威啤酒",
"num": 10,
"price": 15
},
"零食": {
"category": "零食",
"id": 3,
"name": "月饼",
"num": 3,
"price": 30
}
}分类组合：按类型分组获取产品名称合并的Set集合
联合其他收集器
Map<String, Set> prodMap =
prodList.stream().collect(Collectors.groupingBy(Product::getCategory,
Collectors.mapping(Product::getName, Collectors.toSet())));
分组结果：
{
"啤酒": [
"青岛啤酒",
"百威啤酒"
],
"零食": [
"面包",
"饼干",
"月饼"
]
}
