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 list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream stream = list.stream();
// 创建一个并行流
Stream 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 stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
Stream 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 personList = new ArrayList();
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 personList = new ArrayList();
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 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 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 personList = new ArrayList();
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 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 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 personList = new ArrayList();
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 names = personList.stream().filter(distinctByKey(Person::getId)).map(Person::getName).collect(Collectors.toList());
System.out.println(names);static  Predicate distinctByKey(Function keyExtractor) {Map seen = new ConcurrentHashMap<>();return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}

结果：

[Lucy, Rose, Jack]

limit

限制从集合中取前 n 位

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

结果：

21
21
22

求乘积：

List list = Arrays.asList(1, 2, 3, 4, 5, 6);// 求乘积
int product = list.stream().reduce((x, y) -> x * y).get();
System.out.println(product);

结果：

720

求最大值：

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

结果：

6
10

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

List personList = new ArrayList();
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);

List personList = new ArrayList();
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);

collect

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

例子1：toList、toSet、toMap

List list = Arrays.asList(1, 2, 3, 4, 5, 5, 6, 6);// 转化为 List
List newList = list.stream().filter(x -> x > 2).collect(Collectors.toList());
System.out.println(newList);// 转化为 Set
Set set = list.stream().filter(x -> x > 2).collect(Collectors.toSet());
System.out.println(set);List personList = new ArrayList();
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 map = personList.stream().filter(person -> person.getAge() > 20).collect(Collectors.toMap(Person::getName, person -> person));
System.out.println(map);

结果：

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

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

例子2：各种统计方法

• 计数：count
• 平均值：averagingInt、averagingLong、averagingDouble
• 最值：maxBy、minBy
• 求和：summingInt、summingLong、summingDouble
• 统计以上所有：summarizingInt、summarizingLong、summarizingDouble

List personList = new ArrayList();
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);

例子3：分组

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

List personList = new ArrayList();
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> part = personList.stream().collect(Collectors.partitioningBy(person -> person.getAge() > 20));
System.out.println(part);// 按性别分组
Map> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
System.out.println(group);// 先按班级分组，再按性别分组
Map>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getClazz, Collectors.groupingBy(Person::getSex)));
System.out.println(group2);

结果：

{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]}}

例子4：joining

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

List personList = new ArrayList();
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);

结果：

Jack, Rose, Tom, Lucy, Lily, Tony

例子5：reducing

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

List personList = new ArrayList();
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);