本文涉及到的知识点有Lambda表达式以及函数式接口，有不了解的小伙伴可以先学习上一篇文章：

Java8 新特性 —— Lambda 表达式、函数接口以及方法引用详解

---

引言

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定我们希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

集合讲的是数据，流讲的是计算！

举个例子：在不使用Stream API 的情况下，要输出一个集合中大于5的数字：

 public List<Integer> filter(List<Integer> list){List<Integer> newList = new ArrayList<>();for (Integer i : list) {if (i > 5){newList.add(i);}}return newList;}

当有了Stream API之后，代码就会变得精简且优雅：

 public List<Integer> filter(List<Integer> list){return list.stream().filter(i -> i > 5).collect(Collectors.toList());}

特性：

1. Stream 自己不会存储元素。
2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行(终止操作)。

Stream API 的使用

1、创建 Stream

1. 通过Collection系列提供的 stream() 获 parallelStream()
2. 通过Arrays中的静态方法 stream() 获取数组流
3. 通过Stream类中的静态方法 of() 创建流
4. 通过Stream类中的iterate() 和 generate() 方法，创建流创建无限流

//创建 Stream
@Test
public void test1(){//1、通过Collection系列提供的stream() 获 parallelStream()List<String> list = new ArrayList<>();Stream<String> s1 = list.stream();//2、通过Arrays中的静态方法stream()获取数组流String[] arr = new String[10];Stream<String> s2 = Arrays.stream(arr);//3、通过Stream类中的静态方法 of() 创建流Stream<String> s3 = Stream.of("aa", "bb", "cc");//4、创建无限流//迭代Stream<Integer> s4 = Stream.iterate(0, (x) -> x + 1);//生成Stream<Double> s5 = Stream.generate(() -> Math.random());
}

2、中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，这就是上文提到的延迟加载，称为“惰性求值”。

（1）筛选与切片

方 法	描 述
filter()	筛选出满足条件的值
distinct()	通过流所生成元素的 hashCode()和 equals()去除重复元素
limit()	截断流, 使其元素不超过给定数量
skip()	跳过元素, 返回一个扔掉了前 n个元素的流。若流中元素不足n个, 则返回一个空流。与 limit(n) 互补

//筛选与切片
@Test
public void test2(){List<String> list = Arrays.asList("Hello", "Java", "Lambda", "Function", "Stream", "Stream", "Stream");//filter() 筛选出满足条件的数据System.out.println("长度大于4的值: ");list.stream().filter(s -> s.length() > 4).forEach(System.out::println);System.out.println("==========================");//limit() 短路流, 当查到满足条件的数据后就不再往下遍历数据System.out.println("查找满足长度大于4的前2个值: 从头遍历，当满足需求时怎会直接退出");list.stream().filter(s -> {System.out.println("查找。。。");return s.length() > 4;}).limit(2).forEach(System.out::println);System.out.println("==========================");//skip() 扔掉前n个值, 输出剩余的值System.out.println("扔掉前2个值, 输出剩余的值");list.stream().skip(2).forEach(System.out::println);System.out.println("==========================");//distinct() 去重System.out.println("去重");list.stream().distinct().forEach(System.out::println);
}

运行后的效果如下：

（2）映射

方 法	描 述
map()	接收一个函数作为参数, 该函数会被应用到每个元素上, 并将其映射成一个新的元素。
flatMap()	接收一个函数作为参数, 将流中的每个值都换成另一个流, 然后把所有流连接成一个流

//映射
@Test
public void test3(){List<String> list = Arrays.asList("Java", "Lambda", "Function", "Stream");System.out.println("将每个单词加上Hello输出: ");list.stream().map(s -> "Hello " + s).forEach(System.out::println);System.out.println("==========================");List<String> list2 = List.of("Java,Lambda,Function,Stream");System.out.println("将这段话拆分成单词, 每个单词加上Hello输出: ");list2.stream().map(s -> Arrays.asList(s.split(","))) //返回Stream<List<String>>.flatMap(Collection::stream)//将Stream里的每个值都转为流并合并, 返回Stream<String>.map(s -> "Hello " + s).forEach(System.out::println);//遍历List<String>
}

运行后的效果如下：

（3）排序

方 法	描 述
sorted()	自然排序(Comparable)
sorted(Comparator comp)	定制排序(Comparator)

// 排序
@Test
public void test4(){List<String> list = Arrays.asList("Java", "Lambda", "Function", "Stream");//自然排序(Comparable)System.out.println("自然排序: ");list.stream().sorted().forEach(System.out::println);System.out.println("==========================");//定制排序(Comparator)System.out.println("按照单词长度排序");list.stream().sorted(Comparator.comparingInt(String::length)).forEach(System.out::println);
}

运行后的效果如下：

3、终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

（1）查找与匹配

方 法	描 述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicatep)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否所有元素都没有匹配
findFirst()	返回第一个元素
findAny()	返回当前流中的任意一个元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代，即它帮我们把迭代做了)

//查找与匹配
@Test
public void test5(){List<String> list = Arrays.asList("Java", "Lambda", "Function", "Stream");//allMatch(Predicate p) 检查是否匹配所有元素boolean allMatch = list.stream().allMatch(s -> s.contains("a"));System.out.println("allMatch: " + allMatch);//anyMatch(Predicatep) 检查是否至少匹配一个元素boolean anyMatch = list.stream().anyMatch(s -> s.contains("a"));System.out.println("anyMatch: " + anyMatch);//noneMatch(Predicate p) 检查是否所有元素都没有匹配boolean noneMatch = list.stream().noneMatch(s -> s.contains("a"));System.out.println("noneMatch: " + noneMatch);//findFirst() 返回第一个元素String findFirst = list.stream().findFirst().orElse("NULL");System.out.println("findFirst: " + findFirst);//findAny() 返回任意一个元素String findAny = list.stream().findAny().orElse("NULL");System.out.println("findAny: " + findAny);//count() 返回流中元素总数long count = list.stream().count();System.out.println("count: " + count);//max(Comparator c) 返回流中最大值(排序完取最大)String max = list.stream().max(Comparator.comparingInt(String::length)).orElse("NUll");System.out.println("max: " + max);//min(Comparator c) 返回流中最小值(排序完取最小)String min = list.stream().min(Comparator.comparingInt(String::length)).orElse("NUll");System.out.println("min: " + min);//forEach(Consumer c) 内部迭代System.out.println("内部迭代: ");list.stream().forEach(System.out::println);
}

运行后的效果如下：

（2）规约

方 法	描 述
reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 Optional<T>

//归约
@Test
public void test6(){List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);//reduce(T identity, BinaryOperator<T> accumulator) 可以将流中元素反复结合起来，得到一个值。返回 TInteger sum1 = list.stream().reduce(0, Integer::sum);//0为起始值, 有起始值就不可能为空System.out.println(sum1);//reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>Optional<Integer> sum2 = list.stream().reduce(Integer::sum);//没有起始值, 放入Optional中，避免空指针System.out.println(sum2.orElse(0));
}

运行后的效果如下：

（3）收集

方 法	描 述
collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的 实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，以下仅对经常使用的几种方法做以演示：

方法	返回类型	作用	示例
toList()	List<T>	把流中元素收集到List	List strs = list.stream().collect(Collectors.toList());
toSet()	Set<T>	把流中元素收集到Set	Set strs = list.stream().collect(Collectors.toSet());
toCollection()	Collection<T>	把流中元素收集到创建的集合	Collection strs = list.stream().collect(Collectors.toCollection(ArrayList : : new));
groupingBy()	Map<K, List<T>>	根据某属性值对流分组，属性为K，结果为V	Map<String, List> map=list.stream() .collect(Collectors.groupingBy(student::getId));

//收集collect(Collector c)
@Test
public void test7(){List<String> test = Arrays.asList("Java", "Lambda", "Function", "Stream");//将长度大于4的 收集到List中List<String> list = test.stream().filter(s -> s.length() > 4).collect(Collectors.toList());System.out.println("list: " + list);//将长度大于4的 收集到List中Set<String> set = test.stream().filter(s -> s.length() > 4).collect(Collectors.toSet());System.out.println("set: " + set);//通过长度将字符串分组Map<Integer, List<String>> map = test.stream().collect(Collectors.groupingBy(String::length));System.out.println("map: " + map);
}

运行后的效果如下：

总结

Stream作为Java 8的一大亮点，它专门针对集合的各种操作提供各种非常便利、简单、高效的API，Stream API主要是通过Lambda表达式完成，极大的提高了程序的效率和可读性，同时Stram API中自带的并行流使得并发处理集合的门槛再次降低，使用Stream API编程无需多写一行多线程的代码就可以非常方便的写出高性能的并发程序。使用Stream API能够使代码更加优雅。