【java--Stream流操作--实践总结】

//for循环 
List<String> list = new ArrayList();
        list.add("A");
        list.add("B");
        list.add("C");
        AtomicInteger i = new AtomicInteger();
        list.forEach(item -> {
            i.getAndIncrement();
            System.out.println(item + "00" + i);
        });

User user1 = new User();
        user1.setId(1);
        user1.setName("A");
        user1.setDateTime(LocalDateTime.now());
        User user2 = new User();
        user2.setId(2);
        user2.setName("B");
        user2.setDateTime(LocalDateTime.of(2021,11,15,0,0,0));
        User user3 = new User();
        user3.setId(2);
        user3.setName("C");
        user3.setDateTime(LocalDateTime.of(2021,11,17,0,0,0));
//List 转 Map 相同的key不按照条件过滤的话 会报错
//这里我们采用取时间最大的来进行过滤重复key的数据
List<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        Map<Integer, User> collect = userList.parallelStream().collect(Collectors.
        toMap(User::getId,
                Function.identity(), (c1, c2) -> c1.getDateTime().isAfter(c2.getDateTime()) ? c1 : c2));
        for (Integer key:collect.keySet()){
            User user = collect.get(key);
            System.out.println(user);
        }
 //结果
User(id=1, name=A, dateTime=2021-11-19T14:06:42.297)
User(id=2, name=C, dateTime=2021-11-17T00:00)

System.out.println("---------分割线-----------");
//分组重复数据也可以按照新值和旧值来进行筛选
//选择在重复的Key中留一个
        Map<Integer, User> collects = userList.stream().
                collect(Collectors.toMap(User::getId, user -> user, (oldValue, newValue) -> newValue));

//结果
---------分割线-----------
User(id=1, name=A, dateTime=2021-11-19T14:06:42.297)
User(id=2, name=C, dateTime=2021-11-17T00:00)

//GroupBy去重 结果是list
Map<Integer, List<User>> collect1 = userList.parallelStream().collect(Collectors.groupingBy(User::getId, Collectors.toList()));
        for (Integer key:collect1.keySet()){
            List<User> user = collect1.get(key);
            System.out.println(user);
        }
//结果
[User(id=1, name=A, dateTime=2021-11-19T14:06:42.297)]
[User(id=2, name=B, dateTime=2021-11-15T00:00), User(id=2, name=C, dateTime=2021-11-17T00:00)]

//GroupBy去重 结果是聚合统计
userList.stream().collect(Collectors.groupingBy(User::getId,Collectors.counting())).forEach((id, count) -> {
            System.out.println(id+"---"+count);
        });
结果：
1---1
2---2

System.out.println("---------分割线-----------");
//分组 带函数处理的形式
        Map<Boolean, List<User>> collect3 = userList.stream().
                collect(Collectors.groupingBy
                        (e -> 1 == e.getId()));
        for (Boolean key:collect3.keySet()){
            List<User> user = collect3.get(key);
            System.out.println(user);
        }
//结果
[User(id=2, name=B, dateTime=2021-11-15T00:00), User(id=2, name=C, dateTime=2021-11-17T00:00)]
[User(id=1, name=A, dateTime=2021-11-19T15:06:31.227)]

//利用Stream流进行分页 
System.out.println("---------分割线-----------");
        //当前页
        int current = 1;
        //每页记录
        int size = 2;
        System.out.println(userList.stream().skip((current - 1) * size).limit(size).collect(Collectors.toList()));

//利用Stream流 按照指定字段  倒序排序
System.out.println("---------分割线-----------");
List<User> resultList = userList.stream()
                .sorted(Comparator.comparing(User::getId)
                        .reversed()).collect(Collectors.toList());
        System.out.println(resultList);
//结果
[User(id=2, name=B, dateTime=2021-11-15T00:00), User(id=2, name=C, dateTime=2021-11-17T00:00), User(id=1, name=A, dateTime=2021-11-19T15:18:09.893)]

//利用Stream流 map进行拿到指定字段的所有值
System.out.println("---------分割线-----------");
 ArrayList<UserTest> list = new ArrayList<>();

list.add(new UserTest("liubei","111",40));
list.add(new UserTest("zhangfei","222",30));
list.add(new UserTest("guanyu","333",35));

System.out.println("\ntest2--age:");
        list.stream().map(n->n.getAge())
                .forEach(n-> System.out.println(n));
//结果
test2--age:
40
30
35