Java 8 集合 Stream

Posted 2022-12-14 teletian

Java 8 是一个成功的版本，新增的内容很实用。比如大家熟悉的 lamda 表达式，集合的 Stream，等等。
本文讲讲 Stream 的使用。

Stream 是什么？

Stream 将要处理的集合看做流，然后方便的对流做操作，比如筛选，排序等等。

Stream 的操作可以分为两大类：

1. 中间操作。就是操作完还是返回一个流，还可以继续做其他操作。
2. 终端操作。就是结束流，流结束之后就不可以再操作了，会返回一个值或者一个新的集合。

Stream 有以下特征：

1. 不改变源数据，会生成一个新的数据。
2. 具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

中间操作有：

1. filter：筛选
2. map/flatMap：映射
3. sorted：排序
4. distinct：去重
5. limit：取前 n 个元素
6. skip：跳过前 n 个元素
7. …

终端操作有：

1. collect：收集
2. foreach：遍历
3. findFirst/findAny：获取单个元素
4. anyMatch：判断是否有满足条件的元素
5. reduce：归约
6. max、min、count：统计
7. …

创建 Stream

1. 通过集合的 stream() 或者 parallelStream() 方法创建

List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();

stream() 创建的是顺序流，由主线程按顺序对流执行操作。
parallelStream() 创建的是并行流，如果对顺序没有要求，可以使用它以多线程并行执行。数据量比较大的时候并行流可以明显提高效率。

2. 使用 java.util.Arrays.stream(T[] array) 方法用数组创建流

int[] array=1,2,3,4,5;
IntStream stream = Arrays.stream(array);

3. 使用 Stream 的静态方法：of()、iterate()、generate()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);

中间操作

filter

传入规则，筛选出符合要求的元素。

例子1（筛选出大于 3 的元素）

Arrays.asList(1, 2, 3, 4, 5).stream()
        .filter(x -> x > 3)
        .forEach(System.out::println);

结果：

4
5

例子2（筛选出年龄大于 20 的人的姓名）

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Jack", 10, "男"));
personList.add(new Person("Rose", 15, "女"));
personList.add(new Person("Tom", 20, "男"));
personList.add(new Person("Lucy", 25, "女"));
personList.add(new Person("Lily", 39, "女"));

personList.stream()
        .filter(person -> person.getAge() > 20)
        .map(Person::getName)
        .forEach(System.out::println);

结果：

Lucy
Lily

map、flatMap

用于映射。

• map：接收一个函数作为参数，按照一定的规则将元素映射为一个新的元素。
  

• flatMap：接收一个函数作为参数，按照一定的规则将每个元素映射为一个新的流，然后把所有流连接成一个流。
  

例子1（将每个数映射为它的平方）

Arrays.asList(1, 2, 3).stream()
        .map(i -> i*i)
        .forEach(System.out::println);

结果

1
4
9

例子2（将筛选出的年龄大于 20 的 Person 对象映射为 name 属性）

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Jack", 10, "男"));
personList.add(new Person("Rose", 15, "女"));
personList.add(new Person("Tom", 20, "男"));
personList.add(new Person("Lucy", 25, "女"));
personList.add(new Person("Lily", 39, "女"));

personList.stream()
        .filter(person -> person.getAge() > 20)
        .map(Person::getName)
        .forEach(System.out::println);

结果：

Lucy
Lily

例子3（将每个元素转化为一个流，然后合并）

List<String> newList = Arrays.asList("a,b,c", "d,e,f,g").stream()
        .flatMap(s -> Arrays.stream(s.split(",")))
        .collect(Collectors.toList());
System.out.println(newList);

结果：

[a, b, c, d, e, f, g]

sorted

排序。

例子1：

List<Integer> sortedList = Arrays.asList(4, 7, 3, 9, 1, 5).stream()
        .sorted(Integer::compareTo)
        .collect(Collectors.toList());
System.out.println(sortedList);

sortedList = Arrays.asList(4, 7, 3, 9, 1, 5).stream()
        .sorted() // 默认升序
        .collect(Collectors.toList());
System.out.println(sortedList);

结果：

[1, 3, 4, 5, 7, 9]
[1, 3, 4, 5, 7, 9]

例子2：

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Lucy", 25, "女", 2));
personList.add(new Person("Rose", 15, "女", 1));
personList.add(new Person("Jack", 10, "男", 1));
personList.add(new Person("Tom", 20, "男", 2));
personList.add(new Person("Tony", 35, "男", 3));
personList.add(new Person("Lily", 30, "女", 3));

// 按年龄排序（升序）
List<String> nameSortedByAge = personList.stream()
        .sorted(Comparator.comparing(Person::getAge))
        .map(Person::getName)
        .collect(Collectors.toList());
System.out.println(nameSortedByAge);

// 按年龄排序（倒序，加 reversed）
nameSortedByAge = personList.stream()
        .sorted(Comparator.comparing(Person::getAge).reversed())
        .map(Person::getName)
        .collect(Collectors.toList());
System.out.println(nameSortedByAge);

// 先按性别再按年龄排序
nameSortedByAge = personList.stream()
        .sorted(Comparator.comparing(Person::getSex).thenComparing(Person::getAge))
        .map(Person::getName)
        .collect(Collectors.toList());
System.out.println(nameSortedByAge);

// 先按性别再按年龄自定义排序（倒序）
nameSortedByAge = personList.stream()
        .sorted((p1, p2) -> 
            if (p1.getSex().equals(p2.getSex())) 
                return p2.getAge() - p1.getAge();
             else 
                return p2.getSex().compareTo(p1.getSex());
            
        )
        .map(Person::getName)
        .collect(Collectors.toList());
System.out.println(nameSortedByAge);

结果：

[Jack, Rose, Tom, Lucy, Lily, Tony]
[Tony, Lily, Lucy, Tom, Rose, Jack]
[Rose, Lucy, Lily, Jack, Tom, Tony]
[Tony, Tom, Jack, Lily, Lucy, Rose]

distinct

去重。

例子1：

String[] arr1 =  "a", "b", "c", "d" ;
String[] arr2 =  "d", "e", "f", "g" ;
List<String> newList = Stream.concat(Stream.of(arr1), Stream.of(arr2))
        .distinct()
        .collect(Collectors.toList());
System.out.println(newList);

结果：

[a, b, c, d, e, f, g]

例子2：
对象去重

List<Person> personList = new ArrayList<Person>();
personList.add(new Person(1001, "Lucy", 25, "女", 2));
personList.add(new Person(1001, "Lucy", 25, "女", 2));
personList.add(new Person(1002,"Rose", 15, "女", 1));
personList.add(new Person(1003,"Jack", 10, "男", 1));

List<String> names = personList.stream()
        .filter(distinctByKey(Person::getId))
        .map(Person::getName)
        .collect(Collectors.toList());
System.out.println(names);

static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) 
    Map<Object, Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;

结果：

[Lucy, Rose, Jack]

limit

限制从集合中取前 n 位

List<Integer> limitList = Stream.iterate(1, x -> x + 2)
        .limit(10)
        .collect(Collectors.toList());
System.out.println(limitList);

结果：

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

skip

跳过前 n 位

List<Integer> limitList = Stream.iterate(1, x -> x + 2)
        .skip(1)
        .limit(10)
        .collect(Collectors.toList());
System.out.println(limitList);

结果：

[3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

终端操作

forEach

Arrays.asList(1, 2, 3, 4, 5).stream()
        .forEach(System.out::println);

结果：

1
2
3
4
5

findFirst

System.out.println(Arrays.asList(1, 2, 3, 4, 5).stream()
        .filter(x -> x > 3)
        .findFirst()
        .get());

结果：

4

findAny

获取任意一个

// findAny 获取任意适用于并行流 parallelStream
System.out.println(Arrays.asList(1, 2, 3, 4, 5).parallelStream()
        .filter(x -> x > 3)
        .findAny()
        .get());

结果：

4 或者 5

anyMatch

是否有满足条件的元素

System.out.println(Arrays.asList(1, 2, 3, 4, 5).stream()
       .anyMatch(x -> x > 3));

reduce

归纳。也称缩减，顾名思义，是把一个流缩减成一个值，用与集合求和、求乘积、求最值等。

求和：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, Java 集合多条件多规则排序 升序 降序 空值处理

 Java 8 集合 Stream
 Java 8 集合 Stream
 Java 8中处理集合的优雅姿势——Stream
 Java 8中处理集合的优雅姿势——Stream
 简洁方便的集合处理——Java 8 stream流