java stream 流操作 一些示例

Map<String, Object> spbm_map = zmdZjcDt1Map.stream()
                .filter(t -> {
                    String tsbz = (String) t.get("TSBZ");//特殊备注
                    if (tsbz.contains("素金")) {
                        return false;
                    }
                    return true;
                })
                .collect(Collectors.toMap(t -> (String) t.get("SPBM"), Function.identity()));

List<User> userList = Lists.newArrayList(
        new User(1L),
        new User(2L),
        new User(3L),
        new User(null),
        new User(3L)
);

{
    System.out.println("---遍历元素，然后过滤出某个字段的集合---");
    {
        List<Long> userIds = new ArrayList<>();
        for (User user : userList) {
            userIds.add(user.getUserId());
        }
        System.out.println(userIds);
    }
    {
        List<Long> userIds = userList.stream()
                .map(User::getUserId)
                .collect(Collectors.toList());
        System.out.println(userIds);
    }
}

{
    System.out.println("---筛选元素---");
    {
        List<Long> userIds = new ArrayList<>();
        for (User user : userList) {
            if (user.getUserId() != null) {
                userIds.add(user.getUserId());
            }
        }
        System.out.println(userIds);
    }
    {
        List<Long> userIds = userList.stream()
                .filter(item -> item.getUserId() != null)
                .map(User::getUserId)
                .collect(Collectors.toList());
        System.out.println(userIds);
    }
}

{
    System.out.println("---去重---");
    {
        Set<Long> userIds = userList.stream()
                .filter(item -> item.getUserId() != null)
                .map(User::getUserId)
                .collect(Collectors.toSet());
        System.out.println(userIds);
    }
    {
        List<Long> userIds = userList.stream()
                .filter(item -> item.getUserId() != null)
                .map(User::getUserId)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(userIds);
    }
}

{
    System.out.println("---数据类型转换---");
    {
        List<String> userIdStrs = userList.stream()
                .map(x -> x.getUserId() != null ? x.getUserId().toString() : null)
                .collect(Collectors.toList());
        System.out.println(userIdStrs);
    }
}

{
    System.out.println("---数组转集合---");
    {
        //创建一个字符串数组
        String[] strArray = new String[]{"a", "b", "c"};
        //转换后的List 属于 java.util.ArrayList 能进行正常的增删查操作
        List<String> strList = Stream.of(strArray).collect(Collectors.toList());
        System.out.println(strList);
    }
}

{
    System.out.println("---集合转 map（不分组）---");
    {
        Map<Long, User> userMap = new HashMap<>();
        for (User user : userList) {
            userMap.put(user.getUserId(), user);
        }
        System.out.println(userMap);
    }
    {
        Map<Long, User> userMap = userList.stream().collect(Collectors.toMap(User::getUserId, v -> v, (k1, k2) -> k1));
        System.out.println(userMap);
    }
}

{
    System.out.println("---集合转map（分组）---");
    {
        Map<Long, List<User>> userListMap = new HashMap<>();
        for (User user : userList) {
            if (userListMap.containsKey(user.getUserId())) {
                userListMap.get(user.getUserId()).add(user);
            } else {
                List<User> users = new ArrayList<>();
                users.add(user);
                userListMap.put(user.getUserId(), users);
            }
        }
        System.out.println(userListMap);
    }
    {
        Map<Long, List<User>> userMap = userList.stream()
                .filter(item -> item.getUserId() != null)
                .collect(Collectors.groupingBy(User::getUserId));
        System.out.println(userMap);
    }
}

{
    System.out.println("---分页操作---");
    {
        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5, 10, 6, 20, 30, 40, 50, 60, 100);
        List<Integer> dataList = numbers.stream()
                .sorted(Integer::compareTo)
                .skip(0).limit(10)
                .collect(Collectors.toList());
        System.out.println(dataList.toString());
    }
    {
        List<User> dataList = userList.stream()
                .filter(item -> item.getUserId() != null)
                .sorted(Comparator.comparing(User::getUserId))
                .skip(0).limit(10)
                .collect(Collectors.toList());
        System.out.println(dataList.toString());
    }
}

{
    System.out.println("---查找与匹配操作---");
    {
        System.out.println("---allMatch（检查是否匹配所有元素）---");
        List<Integer> list = Arrays.asList(10, 5, 7, 3);
        boolean allMatch = list.stream().allMatch(x -> x > 2);//是否全部元素都大于2
        System.out.println(allMatch);
    }
    {
        System.out.println("---findFirst（返回第一个元素）---");
        List<Integer> list = Arrays.asList(10, 5, 7, 3);
        Optional<Integer> first = list.stream().findFirst();
        Integer val = first.get();
        System.out.println(val);//输出10
    }
    {
        System.out.println("---reduce（可以将流中元素反复结合起来，得到一个值）---");
        List<Integer> list = Arrays.asList(10, 5, 7, 3);
        Integer result = list.stream().reduce(2, Integer::sum);
        System.out.println(result);//输出27，其实相当于2+10+5+7+3，就是一个累加
    }
}

{
    System.out.println("---并行操作---");
    {
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        // 采用并行计算方法，获取空字符串的数量
        long count = strings.parallelStream().filter(String::isEmpty).count();
        System.out.println(count);
    }
}

集合转 map（不分组）

打开Collectors.toMap方法源码，一起来看看到底是啥。

public static <T, K, U>
Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                Function<? super T, ? extends U> valueMapper,
                                BinaryOperator<U> mergeFunction) {
    return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}

从参数表可以看出：

• 第一个参数：表示 key
• 第二个参数：表示 value
• 第三个参数：表示某种规则

上文中的Collectors.toMap(User::getUserId, v -> v, (k1,k2) -> k1)，表达的意思就是将userId的内容作为key，v -> v是表示将元素user作为value，其中(k1,k2) -> k1表示如果存在相同的key，将第一个匹配的元素作为内容，第二个舍弃！

并行操作

所谓并行，指的是多个任务在同一时间点发生，并由不同的cpu进行处理，不互相抢占资源；而并发，指的是多个任务在同一时间点内同时发生了，但由同一个cpu进行处理，互相抢占资源。

这点上大家一定要区分清楚，别弄混了！

stream api 的并行操作和串行操作，只有一个方法区别，其他都一样，例如下面我们使用parallelStream来输出空字符串的数量：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 采用并行计算方法，获取空字符串的数量
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

在实际使用的时候，并行操作不一定比串行操作快！对于简单操作，数量非常大，同时服务器是多核的话，建议使用Stream并行！反之，采用串行操作更可靠！

文章参考:微信公众-java极客技术-深度掌握java stream 流操作，让你的代码高出一个逼格！