由于Java8的新特性包含的内容也挺多的，这里就分多篇文章进行总结。在上篇文章中我们讲了lambda表达式，如果不熟悉的小伙伴可以去看一下。https://blog.csdn.net/sunshunli/article/details/115290466
记得在项目中被大佬说不能总活在过去，Java8的用起来，今天就整理整理学习学习。
一、概述
我们先总览一下Stream主要包含那些东西。
Modifier and Type Method and Description booleanallMatch(Predicate<? super T> predicate)返回此流中的所有元素是否匹配所提供的谓词。
booleananyMatch(Predicate<? super T> predicate)返回此流中的任何元素是否匹配所提供的谓词。
static <T> Stream.Builder<T>builder()返回一个
Stream生成器。<R,A> Rcollect(Collector<? super T,A,R> collector)执行 mutable reduction操作对元素的使用
Collector流。<R> Rcollect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)执行该流的元素 mutable reduction操作。
static <T> Stream<T>concat(Stream<? extends T> a, Stream<? extends T> b)创建一个懒洋洋的级联流的元素的所有元素的第一流通过第二个流的元素。
longcount()返回此流中元素的计数。
Stream<T>distinct()返回一个包含不同的元素流（根据
Object.equals(Object)）这个流。static <T> Stream<T>empty()返回一个空的顺序
Stream。Stream<T>filter(Predicate<? super T> predicate)返回由该流的元素组成的流，该元素与给定的谓词匹配。
Optional<T>findAny()返回一个
Optional描述一些流元素，或一个空的Optional如果流是空的。Optional<T>findFirst()返回一个
Optional描述此流的第一个元素，或者一个空的Optional如果流是空的。<R> Stream<R>flatMap(Function<? super T,? extends Stream<? extends R>> mapper)返回由将所提供的映射函数应用到每个元素的映射流的内容替换此流的每个元素的结果的结果流。
DoubleStreamflatMapToDouble(Function<? super T,? extends DoubleStream> mapper)返回一个包含有一个映射的流应用提供的映射功能，每个元件产生的内容替换此流的每个元素的结果
DoubleStream。IntStreamflatMapToInt(Function<? super T,? extends IntStream> mapper)返回一个包含有一个映射的流应用提供的映射功能，每个元件产生的内容替换此流的每个元素的结果
IntStream。LongStreamflatMapToLong(Function<? super T,? extends LongStream> mapper)返回一个包含有一个映射的流应用提供的映射功能，每个元件产生的内容替换此流的每个元素的结果
LongStream。voidforEach(Consumer<? super T> action)对该流的每个元素执行一个动作。
voidforEachOrdered(Consumer<? super T> action)对该流的每个元素执行一个操作，如果流有一个定义的遇到顺序，则在该流的遇到顺序中执行一个动作。
static <T> Stream<T>generate(Supplier<T> s)返回一个无穷序列无序流，其中每个元素是由提供
Supplier生成。static <T> Stream<T>iterate(T seed, UnaryOperator<T> f)返回一个无穷序列有序
Stream由最初的一元seed函数的f迭代应用产生的，产生一个由seed，f(seed)，f(f(seed))Stream，等。Stream<T>limit(long maxSize)返回一个包含该流的元素流，截断长度不超过
maxSize。<R> Stream<R>map(Function<? super T,? extends R> mapper)返回一个流，包括将给定函数应用到该流元素的结果。
DoubleStreammapToDouble(ToDoubleFunction<? super T> mapper)返回一个包含应用给定的功能，该流的元素的结果
DoubleStream。IntStreammapToInt(ToIntFunction<? super T> mapper)返回一个包含应用给定的功能，该流的元素的结果
IntStream。LongStreammapToLong(ToLongFunction<? super T> mapper)返回一个包含应用给定的功能，该流的元素的结果
LongStream。Optional<T>max(Comparator<? super T> comparator)返回最大元本流根据提供的
Comparator。Optional<T>min(Comparator<? super T> comparator)返回最小元本流根据提供的
Comparator。booleannoneMatch(Predicate<? super T> predicate)返回此流中的任何元素是否匹配所提供的谓词。
static <T> Stream<T>of(T... values)返回一个元素为指定值的顺序排列的流。
static <T> Stream<T>of(T t)返回一个包含一个元素的顺序
Stream。Stream<T>peek(Consumer<? super T> action)返回由该流的元素组成的流，并在所提供的流中执行所提供的每个元素上的动作。
Optional<T>reduce(BinaryOperator<T> accumulator)对这一 reduction流元素，使用 associative累积函数，并返回一个
Optional描述价值减少，如果任何。Treduce(T identity, BinaryOperator<T> accumulator)对这一 reduction流元素，使用提供的价值认同和 associative累积函数，返回值减少。
<U> Ureduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)对这一 reduction流元素，使用提供的身份，积累和组合功能。
Stream<T>skip(long n)返回一个包含此流的其余部分丢弃的流的第一
n元素后流。Stream<T>sorted()返回由该流的元素组成的流，按自然顺序排序。
Stream<T>sorted(Comparator<? super T> comparator)返回一个包含该流的元素流，根据提供的
Comparator排序。Object[]toArray()返回包含此流元素的数组。
<A> A[]toArray(IntFunction<A[]> generator)返回一个数组包含该流的元素，使用提供的
generator函数分配的返回的数组，以及可能对分区执行或调整所需的任何额外的数组。
问题来了，什么是Stream
Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。
Stream可以由数组或集合创建，对流的操作分为两种：
- 中间操作，每次返回一个新的流，可以有多个。
- 终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。
另外，Stream有几个特性：
- stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
- stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
- stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
二、Stream的创建
1、stream可以通过集合数组创建
List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();
2、使用java.util.Arrays.stream(T[] array)方法用数组创建流
int[] array={1,3,5,6,8};
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);
stream2.forEach(System.out::println);
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);
输出结果：
0 3 6 9
0.6796156909271994
0.1914314208854283
0.8116932592396652
stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：
如果流中的数据量足够大，并行流可以加快处速度。
除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：
Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();
三 Stream的使用
在使用stream之前，先理解一个概念：Optional 。
Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
流的中间操作：
1、筛选与接片：
- filter：过滤流中的某些元素
- limit(n)：获取n个元素
- skip(n)：跳过n元素，配合limit(n)可实现分页
- distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);
Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14
.distinct() //6 7 9 8 10 12 14
.skip(2) //9 8 10 12 14
.limit(2); //9 8
newStream.forEach(System.out::println);2、映射：
- map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
- flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
List<String> list = Arrays.asList("a,b,c", "1,2,3");
//将每个元素转成一个新的且不带逗号的元素
Stream<String> s1 = list.stream().map(s -> s.replaceAll(",", ""));
s1.forEach(System.out::println); // abc 123
Stream<String> s3 = list.stream().flatMap(s -> {
//将每个元素转换成一个stream
String[] split = s.split(",");
Stream<String> s2 = Arrays.stream(split);
return s2;
});
s3.forEach(System.out::println); // a b c 1 2 33、排序
- sorted()：自然排序，流中元素需实现Comparable接口
- sorted(Comparator com)：定制排序，自定义Comparator排序器
List<String> list = Arrays.asList("aa", "ff", "dd");
//String 类自身已实现Compareable接口
list.stream().sorted().forEach(System.out::println);// aa dd ff
Student s1 = new Student("aa", 10);
Student s2 = new Student("bb", 20);
Student s3 = new Student("aa", 30);
Student s4 = new Student("dd", 40);
List<Student> studentList = Arrays.asList(s1, s2, s3, s4);
//自定义排序：先按姓名升序，姓名相同则按年龄升序
studentList.stream().sorted(
(o1, o2) -> {
if (o1.getName().equals(o2.getName())) {
return o1.getAge() - o2.getAge();
} else {
return o1.getName().compareTo(o2.getName());
}
}
).forEach(System.out::println);4、消费
- peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值；而peek接收的是Consumer表达式，没有返回值。
Student s1 = new Student("aa", 10);
Student s2 = new Student("bb", 20);
List<Student> studentList = Arrays.asList(s1, s2);
studentList.stream()
.peek(o -> o.setAge(100))
.forEach(System.out::println);
//结果：
Student{name='aa', age=100}
Student{name='bb', age=100} 流的终止操作：
1、匹配、聚合操作
- allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
- noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
- anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
- findFirst：返回流中第一个元素
- findAny：返回流中的任意元素
- count：返回流中元素的总个数
- max：返回流中元素最大值
- min：返回流中元素最小值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean allMatch = list.stream().allMatch(e -> e > 10); //false
boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true
boolean anyMatch = list.stream().anyMatch(e -> e > 4); //true
Integer findFirst = list.stream().findFirst().get(); //1
Integer findAny = list.stream().findAny().get(); //1
long count = list.stream().count(); //5
Integer max = list.stream().max(Integer::compareTo).get(); //5
Integer min = list.stream().min(Integer::compareTo).get(); //12、规约操作
在了解规约操作前，先了解几个关键概念：初始值的定义（Identity)，累加器（Accumulator)，组合器（Combiner）
在深入讨论 Stream.reduce() 功能之前，让我们先了解几个概念
Identity : 定义一个元素代表是归并操作的初始值，如果Stream 是空的，也是Stream 的默认结果
Accumulator: 定义一个带两个参数的函数，第一个参数是上个归并函数的返回值，第二个是Strem 中下一个元素。
Combiner: 调用一个函数来组合归并操作的结果，当归并是并行执行或者当累加器的函数和累加器的实现类型不匹配时才会调用此函数。
例子：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int result = numbers
.stream()
.reduce(0, (subtotal, element) -> subtotal + element);
assertThat(result).isEqualTo(21)
上面示例中，reduce 方法的第一个参数 0 是 identity ，此参数用来保存归并参数的初始值，当Stream 为空时也是默认的返回值。(subtotal, element) -> subtotal + element 是accumulator ，第一个参数是上次累计的和，第二个参数是数据流的下一个元素。为了使代码更简洁，我们可以用方法引用来代替 lambda 表达式
int result = numbers.stream().reduce(0, Integer::sum);
assertThat(result).isEqualTo(21);
当然，我们可以用reduce 方法处理其他类型的 stream，例如，可以操作一个 String 类型的数组，把数组的字符串进行拼接。
List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
String result = letters
.stream()
.reduce("", (partialString, element) -> partialString + element);
assertThat(result).isEqualTo("abcde");另外，我们可以并行地归并元素（并行归并，下面会详细讲解），如下并行归并一个数字数组来求和
List<Integer> ages = Arrays.asList(25, 30, 45, 28, 32);
int computedAges = ages.parallelStream().reduce(0, (a, b) -> a + b, (a,b)->a*b);
System.out.println(computedAges);当对一个流进行并行操作时，在运行时会把流分割多个子流来并行操作。在上面例子中，我们需要一个函数来组合各个子流返回的结果，这个函数就是前面提到的Combiner。
3、收集(collect)
collect，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。
collect主要依赖java.util.stream.Collectors类内置的静态方法。
归集(toList/toSet/toMap)：
因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。
下面用一个案例演示toList、toSet和toMap：
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
.collect(Collectors.toMap(Person::getName, p -> p));
System.out.println("toList:" + listNew);
System.out.println("toSet:" + set);
System.out.println("toMap:" + map);
}
}
toList：[6, 4, 6, 6, 20]
toSet：[4, 20, 6]
toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}
统计(count/averaging)
Collectors提供了一系列用于数据统计的静态方法：
- 计数：count
- 平均值：averagingInt、averagingLong、averagingDouble
- 最值：maxBy、minBy
- 求和：summingInt、summingLong、summingDouble
- 统计以上所有：summarizingInt、summarizingLong、summarizingDouble
案例：统计员工人数、平均工资、工资总额、最高工资:
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
// 求总数
Long count = personList.stream().collect(Collectors.counting());
// 求平均工资
Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
// 求最高工资
Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
// 求工资之和
Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
// 一次性统计所有信息
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println("员工总数：" + count);
System.out.println("员工平均工资：" + average);
System.out.println("员工工资总和：" + sum);
System.out.println("员工工资所有统计：" + collect);
}
}
运行结果：
员工总数：3
员工平均工资：7900.0
员工工资总和：23700
员工工资所有统计：DoubleSummaryStatistics{count=3, sum=23700.000000,min=7000.000000, average=7900.000000, max=8900.000000}
分组(partitioningBy/groupingBy)：
- 分区：将
stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。 - 分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。
案例：将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, "male", "New York"));
personList.add(new Person("Jack", 7000, "male", "Washington"));
personList.add(new Person("Lily", 7800, "female", "Washington"));
personList.add(new Person("Anni", 8200, "female", "New York"));
personList.add(new Person("Owen", 9500, "male", "New York"));
personList.add(new Person("Alisa", 7900, "female", "New York"));
// 将员工按薪资是否高于8000分组
Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
// 将员工按性别分组
Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
// 将员工先按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
System.out.println("员工按薪资是否大于8000分组情况：" + part);
System.out.println("员工按性别分组情况：" + group);
System.out.println("员工按性别、地区：" + group2);
}
}
接合(joining)
joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
System.out.println("所有员工的姓名：" + names);
List<String> list = Arrays.asList("A", "B", "C");
String string = list.stream().collect(Collectors.joining("-"));
System.out.println("拼接后的字符串：" + string);
}
}
运行结果：
所有员工的姓名：Tom,Jack,Lily
拼接后的字符串：A-B-C
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
