利用java8新特性，可以用简洁高效的代码来实现一些数据处理
 
List分组、List转Map、String转List、mapKey转list、循环map、过滤Filter、List转String
 
 
 
1、分组
 List里面的对象元素，以某个属性来分组，将属性相同的放在一起：
 
//List 以名称分组 Map<String, List<User>>
public static void testGroupBy1(List<User> users) {
    Map<String, List<User>> groupByMap = users.stream().collect(Collectors.groupingBy(User::getName));
    for (Map.Entry<String, List<User>> entry : groupByMap.entrySet()) {
        System.out.println("分组对应的key:"+ entry.getKey() +";对应的value:"+ entry.getValue() +";");
    }
    //        分组对应的key:lisi;对应的value:[User{id=2, name='lisi', age=19, grade=50.0}];
    //        分组对应的key:zhangsan;对应的value:[User{id=1, name='zhangsan', age=20, grade=60.0}, User{id=5, name='zhangsan', age=20, grade=70.0}];
    //        分组对应的key:wangwu;对应的value:[User{id=3, name='wangwu', age=20, grade=60.0}, User{id=4, name='wangwu', age=20, grade=70.0}];
}

//List 以名称年龄 Map<Integer, List<User>>
public static void testGroupBy2(List<User> users) {
    Map<Integer,List<User>> groupByMap = users.stream().collect(Collectors.groupingBy(b -> b.getAge()));
    for (Map.Entry<Integer, List<User>> entry : groupByMap.entrySet()) {
        System.out.println("分组对应的key:"+ entry.getKey() +";对应的value:"+ entry.getValue() +";");
    }
    //        分组对应的key:19;对应的value:[User{id=2, name='lisi', age=19, grade=50.0}];
    //        分组对应的key:20;对应的value:[User{id=1, name='zhangsan', age=20, grade=60.0}, User{id=3, name='wangwu', age=20, grade=60.0}, User{id=4, name='wangwu', age=20, grade=70.0}, User{id=5, name='zhangsan', age=20, grade=70.0}];
}    
 
2、List转Map
 
id为key（不重复），apple对象为value，可以这么做：
 
public static void testList2Map1(List<User> users) {
    Map<Long, User> maps = users.stream().collect(Collectors.toMap(User::getId, Function.identity()));
    for (Map.Entry<Long, User> entry : maps.entrySet()) {
        System.out.println("分组对应的key:"+ entry.getKey() +";对应的value:"+ entry.getValue() +";");
    }
    //        分组对应的key:1;对应的value:User{id=1, name='zhangsan', age=20, grade=60.0};
    //        分组对应的key:2;对应的value:User{id=2, name='lisi', age=19, grade=50.0};
    //        分组对应的key:3;对应的value:User{id=3, name='wangwu', age=20, grade=60.0};
    //        分组对应的key:4;对应的value:User{id=4, name='wangwu', age=20, grade=70.0};
    //        分组对应的key:5;对应的value:User{id=5, name='zhangsan', age=20, grade=70.0};
}
 

 /**
  * List -> Map
  * 需要注意的是：
  * toMap 如果集合对象有重复的key，会报错Duplicate key ....
  *  apple1,apple12的id都为1。
  *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
  */
 
public static void testList2Map2(List<User> users) {
    Map<String, User> maps = users.stream().collect(Collectors.toMap(User::getName, a -> a,(k1,k2)->k1));
    for (Map.Entry<String, User> entry : maps.entrySet()) {
        System.out.println("分组对应的key:"+ entry.getKey() +";对应的value:"+ entry.getValue() +";");
    }
    //        分组对应的key:lisi;对应的value:User{id=2, name='lisi', age=19, grade=50.0};
    //        分组对应的key:zhangsan;对应的value:User{id=1, name='zhangsan', age=20, grade=60.0};
    //        分组对应的key:wangwu;对应的value:User{id=3, name='wangwu', age=20, grade=60.0};
}
 
3、过滤Filter、从集合中过滤出来符合条件的元素：
 
public static void testFilter(List<User> users) {
    List<User> filterList = users.stream().filter(a -> a.getName().equals("zhangsan")).collect(Collectors.toList());
    for(User filter : filterList){
        System.out.println("过滤出来的集合:"+filter);
    }
    //        过滤出来的集合:User{id=1, name='zhangsan', age=20, grade=60.0}
    //        过滤出来的集合:User{id=5, name='zhangsan', age=20, grade=70.0}
}
 
4.过滤统计求和、将集合中的数据按照某个属性求和:
 
//计算张三总分
public static void testSum(List<User> users) {
    List<User> filterList = users.stream().filter(a -> a.getName().equals("zhangsan")).collect(Collectors.toList());
    Double gradeSum = filterList.stream().map(User::getGrade).reduce((result, item) -> result + item).get();
    System.out.println("总和:"+gradeSum);

    // BigDecimal 类型的求和
    /*BigDecimal amount = list.stream()
            // 将对象的mongey取出来map为Bigdecimal
            .map(b -> b.getAmount())
            // 使用reduce聚合函数,实现累加器
            .reduce(BigDecimal.ZERO, BigDecimal::add);*/
}


    List list= users.stream()
            .filter(b -> "zhangsan".equals(b.getName()))
            //.filter(b -> b.getGrade() == 60 )
            .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(b -> b.getId()))), ArrayList::new));
//        过滤name等于zhangsan，
//        去重->将过滤后的转set，key为id（set集合key不能重复）->在转为ArrayList
 

 5、查找流中最大 最小值    
 
Optional<User> maxDish = users.stream().
            collect(Collectors.maxBy(Comparator.comparing(User::getAge)));
    maxDish.ifPresent(System.out::println);

    Optional<User> minDish = users.stream().
            collect(Collectors.minBy(Comparator.comparing(User::getAge)));
    minDish.ifPresent(System.out::println);
 

 6、字符串分隔，并转为Long型集合：
 
String tenantIds = “1,2,3,4,5,6”；
List<Long> listIds = Arrays.asList(tenantIds.split(",")).stream().map(s -> Long.parseLong(s)).collect(Collectors.toList());
 
7、测试Map转List
 
    Map<Long, User> maps = users.stream().collect(Collectors.toMap(User::getId, Function.identity()));
    List<User> userList = maps.entrySet().stream().map(Map.Entry::getValue).collect(Collectors.toList());
 
8、 List 对象取里面的字段转list数组，以，间隔把List转成String
 
    List<Long> userIds = users.stream().map(user -> user.getId()).collect(Collectors.toList());
    // 以，间隔把List转成String
    Joiner.on(",").join(userIds);
 
9、两个、多个List合并成一个List并去重
 
Set<String> set = new HashSet<>(listA);
set.addAll(listB);

List<Integer> listAll = new ArrayList<Integer>();
listAll.addAll(list1);
listAll.addAll(list2);
listAll = new ArrayList<Integer>(new LinkedHashSet<>(listAll));
 

    每天努力一点，每天都在进步

【需求】：获取List<Map>数据集中每项的key值，如List<map>=[{测试1：测试一，测试2：测试二}，{测试1：测试三，测试2：测试四},{测试1：测试五，测试2：测试六},{测试1：测试七，测试2：测试八}]
 
返回结果List<String>=测试1，测试2
 
【解决】：
 

public List<String> GetMapKey(List<Map> listResult)
  {
    if ((listResult != null) && (!listResult.isEmpty()))
    {
      List listKey = new ArrayList();

      Map mapResult = (Map)listResult.get(0);

      Set mapKeySet = mapResult.keySet();

      String listHead = "";

      Iterator iteratorKey = mapKeySet.iterator();
      while (iteratorKey.hasNext()) {
        listHead = iteratorKey.next();
        listKey.add(listHead);
      }

      return listKey;
    }
    return null;
  }

 

 

list转map的时候，忘记了map的key不能重复的问题；
 
 
 
其实初衷就是想 利用map的key不能重复的问题。。。。
 
 
 
将list转为map，原以为是遍历list的方式，存map，然后map的key重复的话，直接覆盖了。。。
 
 
 
但是java8 中stream 确给我挖了个坑。。。
 
 
 
List<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("zhangsan");

        //1 stream 流式判断是否 x1和x2相同，相同则取x1
        Map<String, String> collect = list.stream().collect(Collectors.toMap(x -> x, x -> "", (x1, x2) -> x1));
        System.out.println("success,map的size为：" + collect.size());

        //2 没有做前后数据的对比，一股脑的往map中塞key
//        Map<String, String> collectError = list.stream().collect(Collectors.toMap(x -> x, x -> ""));
//        System.out.println("error: java.lang.IllegalStateException: Duplicate key ");

        //3 map中判断是否存在，不存在就put，存在就不要了
        Map map = new HashMap();
        for (String str : list) {
            if (!map.containsKey(str)) {
                map.put(str, "");
            }
        }
        System.out.println("success,map的size为：" + map.size());

        //4 map中直接put。有形同的就直接更新了。。可以保证唯一性
        Map map1 = new HashMap();
        for (String str : list) {
            map1.put(str,"");
        }
        System.out.println("success,map1的size为：" + map1.size());
 
 
 
另：如果是以某个对象的某个属性作为key，则stream的写法也就是和getKey不通而已
 
 
 
        /**
         * List -> Map
         * 需要注意的是：
         * toMap 如果集合对象有重复的key，会报错Duplicate key ....
         *  apple1,apple12的id都为1。
         *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
         */
       Map<Integer, Apple> appleMap = appleList.stream().collect(Collectors.toMap(Apple::getId, a -> a, (k1, k2) -> k1));
 
 
 
补充的是，不管那种方法，list是否为空，对操作不受影响。。。。所以，不用考虑。。。
 
 
 
 
 
//TODO 
 
1，MAP 中key不能重复的原理
 
2，stream不加判断是否相同的判断，putkey duplicate key的问题；；加了判断，只是前后两个比较的吗？？
 
贴个链接，谢谢  https://www.cnblogs.com/yangweiqiang/p/6934671.html
 
 
 
 

  话不多说，看代码和效果
 
 
 
     /**
     * 根据map中的某个key 去除List中重复的map
     * @author  shijing
     * @param list
     * @param mapKey
     * @return
     */
    public static List<Map<String, Object>> removeRepeatMapByKey(List<Map<String, Object>> 
           list, String mapKey){
        if (CollectionUtils.isNullOrEmpty(list)) return null;

        //把list中的数据转换成msp,去掉同一id值多余数据，保留查找到第一个id值对应的数据
        List<Map<String, Object>> listMap = new ArrayList<>();
        Map<String, Map> msp = new HashMap<>();
        for(int i = list.size()-1 ; i>=0; i--){
            Map map = list.get(i);
            String id = (String)map.get(mapKey);
            map.remove(mapKey);
            msp.put(id, map);
        }
        //把msp再转换成list,就会得到根据某一字段去掉重复的数据的List<Map>
        Set<String> mspKey = msp.keySet();
        for(String key: mspKey){
            Map newMap = msp.get(key);
            newMap.put(mapKey, key);
            listMap.add(newMap);
        }
        return listMap;
    }
 
测试：
 
public static void main(String[] args) {
        Map<String, Map> msp = new HashMap<String, Map>();
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        List<Map<String, Object>> listMap = new ArrayList<Map<String,Object>>();
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("id", "1123");
        map1.put("name", "张三");
        Map<String, Object> map2 = new HashMap<String, Object>();
        map2.put("id", "2");
        map2.put("name", "李四");
        Map<String, Object> map3 = new HashMap<String, Object>();
        map3.put("id", "1123");
        map3.put("name", "王五");
        Map<String, Object> map4 = new HashMap<String, Object>();
        map4.put("id", "3");
        map4.put("name", "赵六");
        list.add(map1);
        list.add(map2);
        list.add(map3);
        list.add(map4);
        System.out.println("初始数据：" + list.toString());
        System.out.println("去重之后：" + removeRepeatMapByKey(list,"id"));
    }
 
结果：
 
初始数据：[{name=张三, id=1123}, {name=李四, id=2}, {name=王五, id=1123}, {name=赵六, id=3}]
 去重之后：[{name=李四, id=2}, {name=赵六, id=3}, {name=张三, id=1123}]