• Java 8 集合 Stream

    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();

    • 1
    • 2
    • 3
    • 4
    • 5

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

    1. 使用 java.util.Arrays.stream(T[] array) 方法用数组创建流
    int[] array={1,2,3,4,5};
IntStream stream = Arrays.stream(array);

    • 1
    • 2
    1. 使用 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);

    • 1
    • 2
    • 3

    中间操作

    filter

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

    filter

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

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

    • 1
    • 2
    • 3

    结果：

    4
5

    • 1
    • 2

    例子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);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    结果：

    Lucy
Lily

    • 1
    • 2
    map、flatMap

    用于映射。

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

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

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

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

    • 1
    • 2
    • 3

    结果

    1
4
9

    • 1
    • 2
    • 3

    例子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);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    结果：

    Lucy
Lily

    • 1
    • 2

    例子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);

    • 1
    • 2
    • 3
    • 4

    结果：

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

    • 1
    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    结果：

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

    • 1
    • 2

    例子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);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    结果：

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

    • 1
    • 2
    • 3
    • 4
    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);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    结果：

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

    • 1

    例子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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    结果：

    [Lucy, Rose, Jack]

    • 1
    limit

    限制从集合中取前 n 位

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

    • 1
    • 2
    • 3
    • 4

    结果：

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

    • 1
    skip

    跳过前 n 位

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

    • 1
    • 2
    • 3
    • 4
    • 5

    结果：

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

    • 1

    终端操作

    forEach

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

    • 1
    • 2

    结果：

    1
2
3
4
5

    • 1
    • 2
    • 3
    • 4
    • 5

    findFirst

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

    • 1
    • 2
    • 3
    • 4

    结果：

    4

    • 1

    findAny

    获取任意一个

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

    • 1
    • 2
    • 3
    • 4
    • 5

    结果：

    4 或者 5

    • 1

    anyMatch

    是否有满足条件的元素

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

    • 1
    • 2

    reduce

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

    求和：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);

// 求和方式 1
int sum = list.stream()
        .reduce((x, y) -> x + y)
        .get();
System.out.println(sum);
// 求和方式 2
sum = list.stream()
        .reduce(Integer::sum)
        .get();
System.out.println(sum);
// 求和方式 3
// 列表中所有元素和要再加上第一个参数
sum = list.stream()
        .reduce(1, Integer::sum);
System.out.println(sum);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    结果：

    21
21
22

    • 1
    • 2
    • 3

    求乘积：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);

// 求乘积
int product = list.stream()
        .reduce((x, y) -> x * y)
        .get();
System.out.println(product);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    结果：

    720

    • 1

    求最大值：

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);

// 求最大值方式 1
int maxvalue = list.stream()
        .reduce((x, y) -> x > y ? x : y)
        .get();
System.out.println(maxvalue);
// 求最大值方式 2
// 列表的最大值和第一个参数再选一个最大值
maxvalue = list.stream()
        .reduce(10, Integer::max);
System.out.println(maxvalue);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    结果：

    6
10

    • 1
    • 2

    max、min、count

    用于对集合进行统计

    // 统计最大值是什么
// 打印 3
int maxValue = Arrays.asList(1, 2, 3).stream()
        .max(Integer::compareTo)
        .get();
System.out.println(maxValue);

// 统计最长的字符串是什么
// 打印 ccc
String maxLengthValue = Arrays.asList("a", "bb", "ccc").stream()
        .max(Comparator.comparing(String::length))
        .get();
System.out.println(maxLengthValue);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    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, "女"));

// 统计年龄最小的人的姓名
// 打印 Jack
String name = personList.stream()
        .min(Comparator.comparingInt(Person::getAge))
        .map(Person::getName)
        .get();
System.out.println(name);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    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, "女"));

// 统计男生的人数
// 打印 2
long count = personList.stream()
        .filter(person -> person.getSex().equals("男"))
        .count();
System.out.println(count);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    collect

    把流收集起来，可以收集成一个新的集合，也可以收集成一个值。

    例子1：toList、toSet、toMap
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 5, 6, 6);

// 转化为 List
List<Integer> newList = list.stream()
        .filter(x -> x > 2)
        .collect(Collectors.toList());
System.out.println(newList);

// 转化为 Set
Set<Integer> set = list.stream()
        .filter(x -> x > 2)
        .collect(Collectors.toSet());
System.out.println(set);

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, "女"));

// 转化为 Mao
Map<String, Person> map = personList.stream()
        .filter(person -> person.getAge() > 20)
        .collect(Collectors.toMap(Person::getName, person -> person));
System.out.println(map);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    结果：

    [3, 4, 5, 5, 6, 6]
[3, 4, 5, 6]
{Lucy=Person@1ddc4ec2, Lily=Person@133314b}

    • 1
    • 2
    • 3

    另外如果想转化为 LinkedList 的话，collect 的参数设为 Collectors.toCollection(LinkedList::new)

    例子2：各种统计方法
    • 计数：count
    • 平均值：averagingInt、averagingLong、averagingDouble
    • 最值：maxBy、minBy
    • 求和：summingInt、summingLong、summingDouble
    • 统计以上所有：summarizingInt、summarizingLong、summarizingDouble
    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, "女"));

// 求总数
long count = personList.stream()
    .collect(Collectors.counting());
System.out.println(count);
// 求平均年龄
double averageAge = personList.stream()
    .collect(Collectors.averagingInt(Person::getAge));
System.out.println(averageAge);
// 求最高年龄
int maxAge = personList.stream()
    .map(Person::getAge)
    .collect(Collectors.maxBy(Integer::compare))
    .get();
System.out.println(maxAge);
// 求年龄之和
Integer sum = personList.stream()
    .collect(Collectors.summingInt(Person::getAge));
System.out.println(sum);
// 一次性统计所有信息
DoubleSummaryStatistics all = personList.stream()
    .collect(Collectors.summarizingDouble(Person::getAge));
System.out.println(all);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    例子3：分组

    partitioningBy：分成两部分
    groupingBy：分成多部分

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

// 按年龄是否大于 20 分组
Map<Boolean, List<Person>> part = personList.stream()
        .collect(Collectors.partitioningBy(person -> person.getAge() > 20));
System.out.println(part);

// 按性别分组
Map<String, List<Person>> group = personList.stream()
        .collect(Collectors.groupingBy(Person::getSex));
System.out.println(group);

// 先按班级分组，再按性别分组
Map<Integer, Map<String, List<Person>>> group2 = personList.stream()
        .collect(Collectors.groupingBy(Person::getClazz, Collectors.groupingBy(Person::getSex)));
System.out.println(group2);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    结果：

    {false=[Person@5b6f7412, Person@27973e9b, Person@312b1dae], true=[Person@7530d0a, Person@27bc2616, Person@3941a79c, Person@506e1b77]}
{女=[Person@27973e9b, Person@7530d0a, Person@27bc2616, Person@3941a79c], 未知=[Person@506e1b77], 男=[Person@5b6f7412, Person@312b1dae]}
{1={女=[Person@27973e9b], 男=[Person@5b6f7412]}, 2={女=[Person@7530d0a], 男=[Person@312b1dae]}, 3={女=[Person@27bc2616, Person@3941a79c]}, 4={未知=[Person@506e1b77]}}

    • 1
    • 2
    • 3
    例子4：joining

    将 stream 中的元素用特定的连接符连接成一个字符串。

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

String names = personList.stream()
        .map(Person::getName)
        .collect(Collectors.joining(", "));
System.out.println(names);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    结果：

    Jack, Rose, Tom, Lucy, Lily, Tony

    • 1
    例子5：reducing

    归约。相比于 stream 本身的 reduce 方法，增加了对自定义归约的支持。

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

// 再过 10 年所有人年龄之和
Integer sum = personList.stream()
        .collect(Collectors.reducing(0, Person::getAge, (i, j) -> (i + j + 10)));
System.out.println(sum);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
  • 相关阅读:
    Android 10.0 Launcher3定制化之folder文件夹文件居中显示的功能实现
    Python数据科学实战教程
    什么时候不要采用微服务架构
    32、rocketMq应用
    Burp+Xray的联动使用
    redis的持久化
    基于AM335X开发板 （ARM Cortex-A8）——Linux系统使用手册 （中）
    Vue模板语法集（上）
    安装windows版本的ros2 humble的时候，最后报错
    view事件传递汇总
  • 原文地址：https://blog.csdn.net/tianjf0514/article/details/128065352