JDK8 Stream流操作

介绍

从 Java8 开始，jdk 新增加了一个 Stream 类，用来补充集合类，它的强大，相信用过它的朋友，能明显的感受到，不用使用for循环就能对集合作出很好的操作。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
操作流程如下：

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

遍历操作

/**
 * jdk8 从集合对象中获取用户ID集合
 * @param userList
 * @return
 */
public List<Long> getUserIds(List<User> userList){
    List<Long> userIds = userList.stream().map(User::getUserId).collect(Collectors.toList());
    return userIds;
}

筛选元素

通过filter方法来筛选出需要的数据

/**
 * jdk8 从集合对象中筛选出用户ID不为空的数据
 * @param userList
 * @return
 */
public List<Long> getUserIds8(List<User> userList){
    List<Long> userIds = userList.stream().filter(item -> item.getUserId() != null).map(User::getUserId).collect(Collectors.toList());
    return userIds;
}

删除重复的内容

Collectors.toSet() 去除重复元素

/**
 * jdk8 从集合对象中筛选出用户ID不为空的数据，并进行去重
 * @param userList
 * @return
 */
public Set<Long> getUserIds(List<User> userList){
    Set<Long> userIds = userList.stream().filter(item -> item.getUserId() != null).map(User::getUserId).collect(Collectors.toSet());
    return userIds;
}

数据类型转换

/**
 * jdk8 将Long类型数据转换成String类型
 * @param userIds
 * @return
 */
public List<String> getUserIds10(List<Long> userIds){
    List<String> userIdStrs = userIds.stream().map(x -> x.toString()).collect(Collectors.toList());
    return userIdStrs;
}

数组转集合

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

集合转Map操作

集合元素中某个主键字段作为key，元素作为value，来实现集合转map的需求

/**
 * jdk8 将集合转换成Map，其中用户ID作为主键key,如果集合对象有重复的key,以第一个匹配到的为主
 * @param userList
 * @return
 */
public Map<Long, User> getMap(List<User> userList){
    Map<Long, User> userMap = userList.stream().collect(Collectors.toMap(User::getUserId, v -> v, (k1,k2) -> k1));
    return userMap;
}

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，将第一个匹配的元素作为内容，第二个舍弃！

集合转map（分组）

/**
 * jdk8 将集合转换成Map，将相同的key，加入到一个集合中，实现分组
 * @param userList
 * @return
 */
public Map<Long, List<User>> getMapGroup(List<User> userList){
    Map<Long, List<User>> userMap = userList.stream().collect(Collectors.groupingBy(User::getUserId));
    return userMap;
}

分页操作

将如下的数组从小到大进行排序，排序完成之后，从第1行开始，查询10条数据出来，操作如下：

//需要查询的数据
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((x, y) -> x.compareTo(y)).skip(0).limit(10).collect(Collectors.toList());
System.out.println(dataList.toString());

其中 skip 参数表示第几行，limit 表示查询的数量，类似页容量。

查找与匹配操作

stream api 还支持对集合进行查找，同时还支持正则匹配模式。

• allMatch（检查是否匹配所有元素）

List<Integer> list = Arrays.asList(10, 5, 7, 3);
boolean allMatch = list.stream()//
        .allMatch(x -> x > 2);//是否全部元素都大于2
System.out.println(allMatch);

• 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

• 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，就是一个累加

并行操作

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

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

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

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