java jdk1.8 使用stream流进行list 分组归类操作

我就废话不多说了，大家还是直接看代码吧~

import com.alibaba.fastjson.JSON;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author czw
*/
public class Foo{
 private String name;
 private String type;
 private Double typeValue;
 private Integer count;
 public Foo(String name, String type, Double typeValue, Integer count) {
   this.name = name;
   this.type = type;
   this.typeValue = typeValue;
   this.count = count;
 }
 public String getName() {
   return name;
 }
 public void setName(String name) {
   this.name = name;
 }
 public String getType() {
   return type;
 }
 public void setType(String type) {
   this.type = type;
 }
 public Double getTypeValue() {
   return typeValue;
 }
 public void setTypeValue(Double typeValue) {
   this.typeValue = typeValue;
 }
 public Integer getCount() {
   return count;
 }
 public void setCount(Integer count) {
   this.count = count;
 }
 @Override
 public String toString() {
   return "Foo{" +
       "name='" + name + '\'' +
       ", type='" + type + '\'' +
       ", typeValue=" + typeValue +
       ", count=" + count +
       '}';
 }
 public static void main(String[] args) {
   List<Foo> fooList = new ArrayList<Foo>();
   fooList.add(new Foo("A","san",1.0,2)) ;
   fooList.add( new Foo("A","nas",13.0,1)) ;
   fooList.add(new Foo("B","san",112.0,3)) ;
   fooList.add(new Foo("C","san",43.0,5)) ;
   fooList.add(new Foo("B","nas",77.0,7)) ;
   List<List<Foo>> groupList = new ArrayList<>();
   fooList.stream()
       .collect(Collectors.groupingBy(Foo::getName,Collectors.toList()))
       .forEach((name,fooListByName)->{
         groupList.add(fooListByName);
       });
   System.out.println(JSON.toJSONString(groupList));
 }
}

输出结果

[
 [{
   "count": 2,
   "name": "A",
   "type": "san",
   "typeValue": 1
 }, {
   "count": 1,
   "name": "A",
   "type": "nas",
   "typeValue": 13
 }],
 [{
   "count": 3,
   "name": "B",
   "type": "san",
   "typeValue": 112
 }, {
   "count": 7,
   "name": "B",
   "type": "nas",
   "typeValue": 77
 }],
 [{
   "count": 5,
   "name": "C",
   "type": "san",
   "typeValue": 43
 }]
]

补充知识：java jdk1.8的stream复杂和简单的分组

获取List对象中的某个参数时：

List<Map<String,String>> param = new ArrayList<>();
Map<String,String> map = new HashMap<>();
map.put("id","1213");
map.put("name","test");
List<String> strList = param.stream().map(key ->key.get("name")).collect(Collectors.toList());

简单参数分组：

List<DamoForm> damoformList = new ArrayList<>();
Map<String, Map<String, List<DamoForm>>> collect = damoformList.stream()
       .collect(Collectors.groupingBy(DamoForm::getId()))
       .entrySet()
       .stream()
       .collect(Collectors.toMap(
           entry -> entry.getKey(),
           entry -> entry.getValue().stream().collect(Collectors.groupingBy(DamoForm::getName()))
       ));

针对List复杂排序，多个条件进行排序：

应用场景：针对List中某个字段的数据进行双重倒序的方式排序，代码有点复杂，不明白的可以留言。

List<DamoForm> damoformList = new ArrayList<>();
List<Map<String, Object>> result = damoformList.stream()
    .collect(Collectors.groupingBy(DamoForm::getPartClass))
    .entrySet()
    .stream()
    .sorted((o1, o2) -> {
      /*
       * 这里排序，任何有1的排在前，全部是0排在后
       */
       Integer sort1 = o1.getValue().stream().anyMatch(item -> item.getIsFlag() > 0) ? -1 : 1;
       Integer sort2 = o2.getValue().stream().anyMatch(item -> item.getIsFlag() > 0) ? -1 : 1;
       return sort1.compareTo(sort2);
    })
    .map(entry -> {
       Map<String, Object> map = Maps.newHashMapWithExpectedSize(2);
       map.put("repairItemTypeName", entry.getKey());
         /*
          * 这里排序，1排在前，0排在后
          */
         List<DamoVO> damoVOList = entry.getValue().stream()
             .sorted(Comparator.comparingInt(o -> (o.getIsFlag() * -1)))
             .collect(Collectors.toList());
         map.put("repairTypeList", itemDescFormList);
         return map;
    })
    .collect(Collectors.toList());

来源：https://blog.csdn.net/wency935486/article/details/81184137