在本节中将介绍Stream API支持的许多操作，这些操作可以完成更复杂的数据查询，如筛选、切片、映射、查找、匹配和归约。还有一些特殊的流如：数值流、来自文件和数组等多种来源的流。
筛选和切片
1.用谓词筛选
Streams接口支持filter方法，该操作会接受一个谓词作为参数，并返回一个包含所有符合谓词的元素的流。例如筛选出所有素菜：
List<Dish> vegetarianMenu = menu.stream().filter(Dish::isVegetarian).collect(toList());
2.筛选各异的元素
流海支持一个叫做distinct的方法，它会返回一个元素各异（根据流所生成的元素的hashCode和equals方法的实现）的流。例如筛选所有的偶数并确保没有重复的：
List<Integer> nums = Arrays.asList(1,2,3,13,12,2,1,2,2,1,2,2,3,4,5);
List<Integer> oddNums = nums.stream().filter(s->s%2==0).distinct().collect(toList());
3.截断流
流支持limit(n)方法，该方法会返回一个不超过给定长度的流，所需的长度作为参数传递给limit，如果流是有序的，则最多返回前n个元素。例如筛选热量超过300卡路里的前3道菜：
List<Dish> limit3 = menu.stream().filter(c->c.getCalories()>300).distinct().limit(3).collect(toList());
4.跳过元素
流还支持skip(n)方法，该方法会返回一个扔掉了前n个元素的流，如果流中元素U不足n个，则返回一个空流。例如：跳过超过300卡路里的头两道菜，并返回剩下的。
List<Dish> skip2 = menu.stream().filter(c->c.getCalories()>300).distinct().skip(2).collect(toList());
映射
比如在SQL中，你可以选择从表中选择一列，Stream API也通过map和flatMap方法提供了类似的工具。
1.对流中每一个元素应用函数
流支持map方法，它接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素。例如下面把Dish::getName传给了map方法，来提取流中的菜名：
List<String> names = menu.stream().map(Dish::getName).collect(toList());
因为getName返回一个String，所以map方法输出的流的类型就是Stream<String>。例如下面把List<String> 映射为List<Integer> 值是String的长度。
List<String> strs = Arrays.asList("lambda","action","java 8","stream");
List<Integer> ints = strs.stream().map(String::length).collect(toList());
如果要找出每道菜的名称有多长可以再加上一个map:
List<Integer> nameLength = menu.stream().map(Dish::getName).map(String::length).collect(toList());
2.流的扁平化
通过下面这个例子介绍流的扁平化：给定字符串数组：["hello","world"]，返回字符数组["h","e","l","o","w","r","d"]。
第1次尝试：你可能觉得很容易，distinct一下就好了
List<String> words = Arrays.asList("hello","world");
List<String[]> collect = words.stream().map(w -> w.split("")).distinct().collect(toList());
但是，传递给map方法的lambda为每个单词返回了一个Stirng[]，因此map返回的流实际上是Stream<String[]>类型的，而我们想要的是Stream<String>类型的
第2次尝试：map和Arrays.stream()
首先要活的一个字符流，而不是字符串数组流，有一个叫做Arrays.stream()的方法可以接收一个数组并产生一个流：例如
String[] words = {"hello","world"};
Stream<String> stream = Arrays.stream(words);
使用这个方法应用到前面的流水线里看看
List<Stream<String>> collect1 = words.stream() .map(w -> w.split("")) .map(Arrays::stream) .distinct() .collect(toList());
还是不行，因为现在得到的是一个流的列表List<Stream<String>>。
第3次尝试：使用flatMap
List<String> collect2 = words.stream() .map(w -> w.split("")) .flatMap(Arrays::stream) .distinct() .collect(toList());
使用flatMap的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化一个流。
映射练习：
1.给定一个数字列表，返回每个数的平方构成的列表：
List<Integer> numbers = Arrays.asList(1,2,3,56,78,9);
List<Integer> collect3 = numbers.stream().map(a -> a * a).collect(toList());
2.给定两个数字列表，返回所有的参数对。
List<Integer> num1 = Arrays.asList(1, 2, 3, 4, 5); List<Integer> num2 = Arrays.asList(1, 2, 3, 4, 5); List<int[]> collect4 = num1.stream() .flatMap(i -> num2.stream().map(j -> new int[]{i, j})) .collect(toList());
3.扩展前一个例子，只返回总和可以被3整除的。
List<int[]> collect5 = num1.stream() .flatMap(i -> num2.stream().filter(j -> (i + j) % 3 == 0).map(j -> new int[]{i, j})) .collect(toList());
查找和匹配
查看数据集中的某些元素是否匹配一个给定的属性，Stream API通过allMatch、anyMatch、noneMatch、findFirst和findAny方法提供了这样的工具
1.至少匹配一个元素 anyMatch
if(menu.stream().anyMatch(m->m.getCalories()>400)){ System.out.println("有卡路里大于400的食物"); }
2.匹配所有元素 allMatch
if(menu.stream().allMatch(Dish::isVegetarian)){ System.out.println("所有菜都是素菜"); }
3.没有匹配 noneMatch
if(menu.stream().noneMatch(m->m.getCalories() < 100)){ System.out.println("所有菜都不小于100卡路里"); }
anyMatch、allMatch、noneMatch这三个操作都用到了短路，就是Java中的 && || 运算符短路在流中的版本。
短路：有些操作不需要处理整个流就可以得到结果。例如一个用and连接起来的大布尔表达式，不管表达式有多长，只要找到一个为false就推断整个表达式为false。
对于流而言，某些操作（allMatch、anyMatch、noneMatch、findFirst、findAny）不用处理整个流就可以得到结果，limit也是一个短路操作。
查找元素
findAndy方法返回当前流中的任意元素：
Optional<Dish> any = menu.stream().filter(Dish::isVegetarian).findAny();
Optional<T>类是一个容器类，代表一个值存在或不存在。例如这个例子，可能会什么都没找到。
isPresent()：optional存在值时返回true，否则返回false。
ifPresent(Consumer<T> block)会在值存在的时候执行给定的代码块，（Consumer接口：传递一个T参数，消费这个T 什么也不返回）。
T get():值存在时返回值，否则抛出一个NoSuchElement异常。
T orElse(T other)：会在值存在时返回值，否则返回一个默认值。
例如：如果找到了输出这个名字，否则什么也不错
menu.stream().filter(Dish::isVegetarian).findAny().ifPresent(d->System.out.println(d.getName()));
findFrist方法返回第一个元素：
menu.stream().filter(Dish::isVegetarian).findFirst().ifPresent(d->System.out.println(d.getName()));
findFrist和findAny：找到第一个元素在并行上限制更多，如果不关心返回的元素是哪个就是用findAny，因为它在是用并行流时限制较少。
归约 reduce
例如查找所有菜的总卡路里，或菜中最高的卡路里是哪个，这类查询需要将流中所有的元素反复结合起来，得到一个值。这样的查询可以被归类为归约操作。
求和：
在是用reduce方法之前，来看看for-each循环来对数字列表中的元素求和：
List<Integer> nums1 = Arrays.asList(1,2,3,4,5); int sum = 0; for(int i : nums1){ sum +=i; }
是用reduce来求和如下：
int reduceSum = nums1.stream().reduce(0, (a, b) -> a + b);
这里的第一个参数 就如上面设置的初始值一样，第二个参数就是一个BinaryOperator<T>来将两个元素结合起来产生一个新值。
在Java 8 中，Integer类有一个现有的静态sum方法来对两个数求和，因此可以改写成：
Integer reduce = nums1.stream().reduce(0, Integer::sum);
reduce还有一个重载版本，它不用接受初始值，但会返回一个Optional对象：
Optional<Integer> reduce = nums1.stream().reduce(Integer::sum);
最大值和最小值：
Optional<Integer> max = nums1.stream().reduce(Integer::max);
Optional<Integer> min = nums1.stream().reduce(Integer::min);
当然也可以写成 (x,y) -> x< y ? x : y;而不是Integer::min，不过后者更好读。
流操作：无状态和有状态
map或feilter等操作会从输入流中获取每一个元素，并在输出流得到0或1个结果。这些操作一般都是无状态的：他们没有内部状态。
但reduce、sum、max等操作需要内部状态类累计结果，不管流中又多少元素要处理，内部状态都是有界的。
相反，sort或distinct等操作一开始都和filter、map差不多--都是接受一个流，再生成一个流（中间操作），但有一个关键的区别。从流中排序和删除重复项时都需要知道先前的历史，我们把这些操作叫做有状态操作。
到目前学到的流的方法如下：
中间操作：
filter、distinct、skip、limit、map、flatMap、sorted。
终端操作：
anyMatch、noneMatch、allMatch、findAny、findFirst、forEach、collect、reduce、count。
小练习：
public class Trader { private final String name; private final String city; }
public class Transaction { private final Trader trader; private final int year; private final int value; }
Trader raoul = new Trader("Raoul", "Cambridge"); Trader mario = new Trader("Mario","Milan"); Trader alan = new Trader("Alan","Cambridge"); Trader brian = new Trader("Brian","Cambridge"); List<Transaction> transactions = Arrays.asList( new Transaction(brian, 2011, 300), new Transaction(raoul, 2012, 1000), new Transaction(raoul, 2011, 400), new Transaction(mario, 2012, 710), new Transaction(mario, 2012, 700), new Transaction(alan, 2012, 950) );
//1.找出2011年发生的所有交易，并按交易额排序(从低到高) List<Transaction> collect = transactions.stream() .filter(t -> t.getYear() == 2011) .sorted(Comparator.comparing(Transaction::getValue)) .collect(toList()); System.out.println(collect);
//2.交易员都在哪些不同的城市工作过? List<String> collect1 = transactions.stream() .map(m -> m.getTrader().getCity()) .distinct() .collect(toList()); System.out.println(collect1);
//3.查找所有来自于剑桥的交易员，并按姓名排序。 List<Trader> collect2 = transactions.stream() .map(m -> m.getTrader()) .filter(m -> m.getCity() == "Cambridge") .distinct() .sorted(Comparator.comparing(Trader::getName)) .collect(toList());
//4.返回所有交易员的姓名字符串，按字母顺序排序 String reduce = transactions.stream() .map(t -> t.getTrader().getName()) .distinct() .sorted() .reduce("", (n1, n2) -> n1 + n2);//效率不高是stirng 拼接 下一节joining
//5.有没有交易员是在米兰工作的 boolean milan = transactions.stream().anyMatch(c -> c.getTrader().getCity().equals("Milan"));
//6.打印生活在剑桥的交易员的所有交易额 transactions.stream() .filter(t->t.getTrader().getCity().equals("Cambridge")) .map(Transaction::getValue) .forEach(System.out::println);
//7.所有交易中，最高的交易额是多少 Optional<Integer> reduce1 = transactions.stream() .map(Transaction::getValue) .reduce(Integer::max);
//8.找到交易额最小的交易 Optional<Transaction> reduce2 = transactions.stream() .reduce((t1, t2) -> t1.getValue() < t2.getValue() ? t1 : t2);
//流还支持min和max方法 Optional<Transaction> smallTransaction = transactions.stream() .min(Comparator.comparing(Transaction::getValue)); smallTransaction.ifPresent(System.out::println);
数值流
前面使用reduce方法计算了元素的总和，例如：
Integer reduce3 = transactions.stream().map(c -> c.getValue()).reduce(0, Integer::sum);
这段代码的问题是，它有一个暗含的装箱成本，每个Integer都必须拆箱成一个原始类型后再进行求和，要是可以像下面这样直接调用sum方法不是更好？
int sum3 = transactions.stream().map(c->c.getValue()).sum();
这是不可能的，因为map方法会生成一个Stream<T>，虽然流中的元素是Integer类型，但Streams接口没有定义sum方法。Stream API提供了原始类型流特化，专门支持处理数值流的方法。
原始类型流特化
Java 8 引入了三个原始类型特化流接口来解决这个问题：IntStream、DoubleStream、LongStream，分别将流中的元素特化为int、long和double，从而避免了暗含的装箱成本。
1.映射到数值流
将流转换为特化版本的常用方法是mapToInt、mapToDouble和mapToLong，这些方法返回一个特化流，而不是Stream<T>。例如：
int sum = transactions.stream().mapToInt(Transaction::getValue).sum();
mapToInt返回一个IntStream而不是Stream<Integer>，然后就可以调用IntStream中的sum方法，如果流是空的，sum默认返回0.还支持其他方法如max、min、average等。
2.转换回对象流
将特化流转回非特化流，可以使用boxed方法：
IntStream intStream = transactions.stream().mapToInt(Transaction::getValue);
Stream<Integer> stream = intStream.boxed();
3.默认值OptionalInt
Optional对于三中原始流特化，也分别有一个Optional原始类型特化版本：OptionalInt、OptionalDouble、OptionalLong。例如要找到最大元素：
OptionalInt max = transactions.stream().mapToInt(Transaction::getValue).max();
如果没有最大值可以给一个默认值：
int i = transactions.stream().mapToInt(Transaction::getValue).max().orElse(1);
数值范围
在Java 8中引入了两个可以用于IntStream和LongStream的静态方法，帮助生成这种1到100之间数字的范围：range和rangeClosed。这两个方法第一个参数 起始值，第二个参数结束值。但range是不包含结束值的，而rangeClosed则包含结束值。就是< 和<=的区别。
IntStream evenNumbers = IntStream.rangeClosed(1,100).filter(i->i%2==0);
System.out.println(evenNumbers.count());//50
如果是range方法 则只有49个结果 因为它不包含最后100这个数字。
range示例：取出1到100之间的勾股数：
Stream<double[]> stream1 = IntStream.rangeClosed(1, 100) .boxed() .flatMap(a -> IntStream.rangeClosed(a, 100) .mapToObj( b -> new double[]{a, b, Math.sqrt(a * a + b * b)} ).filter(t -> t[2] % 1 == 0)); stream1.limit(3).forEach(t -> System.out.println(t[0] + "," + t[1] + "," + t[2]));
构建流
1.由值创建流
Stream.of方法可以显示的创建一个流，它可以接受任意数量的参数。例如：创建一个字符串流，将字符串转换为大写，再打印出来：
Stream<String> stringStream = Stream.of("Java 8", "Lambdas", "in", "Action");
stringStream.map(String::toUpperCase).forEach(System.out::println);
还可以使用mepty得到一个空流：
Stream<String> emptyString = Stream.empty();
2.由数组创建流
Arrays.Stream可以从数组创建一个流，它接受一个数组作为参数，例如你可以讲一个原始类型int的数组转换成一个IntStream：
int[] nums4 = {2,3,5,56,6,4,4,45,234,2}; IntStream stream2 = Arrays.stream(nums4);
3.由文件生成流
Files.lines可以从文件得到一个流，其中的每个元素都是该文件的一行。
Stream<String> lines = Files.lines(Paths.get("/Users/baidawei/Desktop/test.txt"), Charset.defaultCharset());
lines.forEach(c->System.out.println(c.toString()));
4.由函数生成流：创建无限流
Stream.iterate和Stream.generate这两个静态方法可以创建所谓的无限流：不像从固定集合创建的流那样有固定大小的流。由这两个产生的流会用给定的函数按需创建值，因此可以无穷的计算下去，一般来说应该使用limit来对这种流加以限制。
4.1 迭代
Stream.iterate(0,n->n+2) .limit(10) .forEach(System.out::println);
iterate 第一个参数是起始值，第二个参数是一个lambda表达式（UnaryOperator<T>)类型的，没有终止条件，按需计算。所以需要limit截断
4.2 生成
与iterate类似，generate也可以让你按需生成一个无限流。但generate不是依次对每个新生成的值应用函数的。它接受一个Supplier<T>类型的Lambda提供新的值：
Stream.generate(Math::random) .limit(5) .forEach(System.out::println);
我们使用的供应源（Math::radom）是无状态的：它不会在任何地方记录任何值。
小结：
1. 、筛选和切片:filter、distinct、skip、limit。
2、映射：map、flatMap。
3、查找：findFirst、findAny。
4、匹配：allMatch、anyMatch、noneMatch。
5、这些方法都利用了短路：找到结果就立即停止计算，没有必要处理整个流。
6、归约：reduce、聚合 计算最大 最小值。
7、filter和map等是无状态的，他们并不存储任何状态。reduce等操作需要存储状态才能计算一个值。sorted和distinct等操作也要存储状态，因为他们需要把六中的所有元素缓存起来才能返回一个新的流。这种操作称为有状态操作。
8、流油三种基本的原始类型特化：IntStream、DoubleStream和LongStream。
9、流不尽可以从集合创建，也可以从值、数组、文件以及iterate与generate等方法创建。
10、无限流是没有固定大小的流。