写了Lambda表达式的博客，怎么能少了对Stream的学习呢！接下来就将我所理解的Stream分享给大家，欢迎指出不足之处...
一、为什么要使用Stream？Stream是什么？在Java中该怎么用呢？
(1)为什么要使用Stream?
Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。
(2) Stream是什么？
首先，Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。
Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。
(3) Stream在Java中如何用呢？
当我们使用Stream流时，一般包含三个步骤：获取一个数据源（source）→ 数据转换 → 执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。
有多种方式产生一个流：
① 从Collection和数组中产生一个流：Collection.stream() Collection.parallelStream()
Arrays.stream(T array) Stream.of(元素)
② 从BufferedReader中产生一个流： Collection.parallelStream()
二、详解流的使用：
(1) map的详解：map 生成的是个 1:1 映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap。
例1：将数组中的字符串转为大写，求平方数
@Test
public void mapTest(){
//将数组的字符串转为大写
String[] wordList = new String[]{"Java","Android","OS","IOS"};
List<String> output = Arrays.stream(wordList).
map(String::toUpperCase).
collect(Collectors.toList());
System.out.println(output);
//平方数
List<Integer> nums = Arrays.asList(1,2,3,4);
List<Integer> squareNums = nums.stream().
map(n -> n * n).
collect(Collectors.toList());
System.out.println(squareNums);
}注意：map(String::toUpperCase)这样的写法，这就是我们上篇博客讲的Lambda表达式的方法引用！诶，大家会不会觉得toUpperCase()这个方法不是String类中的静态方法，为啥可以这样调用呢？
map((str) -> str.toUpperCase()) 还原之前的Lambda表达式，toUpperCase()是String的成员方法，但是str会作为参数原封不动的传递给表达式str.toUpperCase()，这样就可以使用String::toUpperCase改写。
(2) filter 的详解：filter对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。
例2：过滤数组中的奇数，留下偶数
@Test
public void filterTest(){
//留下偶数
Integer[] nums = {1,2,3,4,5,6};
Integer[] evens = Stream.of(nums).
filter(n -> n%2 == 0).
toArray(Integer[]::new);
for (Integer even : evens) {
System.out.println(even);
}
}例3：将文件中的单词挑出，转为小写，排序并保证不重复
@Test
public void testDistinct() {
try {
//
BufferedReader br = new BufferedReader(new FileReader("src/main/resource/test.txt"));
//获取不重复的单词集合
List<String> wordList = br.lines().
flatMap(line -> Stream.of(line.split(" "))).
filter(word -> word.length() > 0).
map(String::toLowerCase).
distinct().
sorted().
collect(Collectors.toList());
System.out.println(wordList);
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}(3) reduce的详解：这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。
例4：字符串拼接，求最小值、最大值、过滤字符串拼接
@Test
public void reduce(){
//字符串连接
String concat1 = Stream.of("A","B","C","D").reduce("", (x,y) -> x.concat(y));
String concat2= Stream.of("A","B","C","D").reduce("", String::concat);
System.out.println(concat1 + concat2);
//求最小值
double minValue1 = Stream.of(-1.5,1.0,-3.0,-2.0).reduce(Double.MAX_VALUE, (x,y) -> Double.min(x, y));
double minValue2 = Stream.of(-1.5,1.0,-3.0,-2.0).reduce(Double.MAX_VALUE, Double::min);
System.out.println(minValue1);
System.out.println(minValue2);
//求最和
int sumValue1 = Stream.of(1,2,3,4).reduce(0, (x,y) -> x + y);
//原因：Integer类中的sum()方法完全可以替代两个数求和，参数类型、个数、返回值相同
int sumValue2 = Stream.of(1,2,3,4).reduce(0, Integer::sum);
System.out.println(sumValue1);
System.out.println(sumValue2);
//过滤字符串并拼接
String concat = Stream.of("a","D","c","B","C","A").
filter(s -> s.compareTo("Z") > 0).
reduce("", String::concat);
System.out.println(concat);
}(4) limit/skip的详解：limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素。
例5：留下数组中的偶数，并扔掉前4 个元素。
@Test
public void testLimitAndSkip() {
List<Integer> list = new ArrayList();
for (int i = 1; i <= 20; i++) {
list.add(i);
}
//limit()返回前n个元素，skip则是扔掉前n个元素
List<Integer> list1 = list.stream().
filter(x -> x % 2 == 0).limit(10).skip(3).collect(Collectors.toList());
System.out.println(list1);
}(5) sorted的详解：对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。
@Test
public void testLimitAndSkip1() {
Integer[] arr = new Integer[]{2,5,3,4,7,8,5,12,13,16,18,19,20};
List<Integer> list = Arrays.asList(arr);
//limit()返回前n个元素，skip则是扔掉前n个元素
List<Integer> list1 = list.stream().
sorted(). //先排序，从I小到大输出
filter(x -> x % 2 == 0).
limit(10).
skip(3).
collect(Collectors.toList());
System.out.println(list1);
}(6) max/min/distinct的详解：保证Stream流集合中元素不重复，找出最大值、最小值等
@Test
public void testMax() {
Integer[] arr = new Integer[]{2,5,3,4,7,8,5,12,13,16,18,19,20};
List<Integer> list = Arrays.asList(arr);
//求最大值
Integer maxValue = list.stream().
max(Integer::compare).get();
System.out.println(maxValue);
//求最小值
Integer minValue = list.stream().
min(Integer::compare).get();
System.out.println(minValue);
}还有forEach()，peek()，allMatch()，anyMatch()，noMatch()方法，自行研究和举例，这里不在一一赘述！
三、Stream总结：
(1) Stream不是数据结构；
(2) 它没有内部存储，它只是用操作管道从 source（数据结构、数组、generator function、IO channel）抓取数据；
(3) 它也绝不修改自己所封装的底层数据结构的数据。例如 Stream 的 filter 操作会产生一个不包含被过滤元素的新 Stream，而不 是从 source 删除那些元素；
(4) 所有 Stream 的操作必须以 lambda 表达式为参数；
(5) 不支持索引访问；使用forEach()遍历数组，不可使用break，continue等关键字跳出循环；
(6) 你可以请求第一个元素findFirst()，但无法请求第二个，第三个，或最后一个。不过请参阅下一项。
(7) 很容易生成数组或者 List。
简单的讲解了一下Java8新特性之Stream语法，希望大家看过后有所收获，共同进步......
欢迎续学：Java8新特性之Stream学习二