JDK8中的Streams API
1.为什么需要stream
stream作为JDK8的一大亮点，它和IO中的输入流或者输出流不是一个概念。在JDK8中，它是对集合对象的功能增强，针对集合对象它提供了各种非常便利的高效聚合操作，并且配合JDK8的Lambda表达式和函数式编程使得对集合的各种操作更加简单。同时还提供了串行和并行两种模式进行对集合的操作。通常编写并发的代码很容易出错，而使用Stream API只需要简单的添加一行代码就能够达到安全高效的并发操作。当一个Stream是并行化的，就无需在写多变成的代码，它使用JDK1.7的FORK/JOIN框架将数据分成多个段，其中每一个都在不同的线程中处理。
2.什么是stream
stream不是一种数据结构，它并没有存储数据，它只是类似一个高级的Iterator，从source（数组、集合、IO等）抓取数据，它并不会修改自己封装的底层数据结构的数据。
流的操作分为两种:
Intermediate：一个流后面可以跟一个或多个Intermediate操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这些操作都是惰性化的，就是仅仅调用到这类方法，还没有开始遍历集合。
Terminal：一个流只能有一个terminal操作，当这个操作执行完毕后，这个流就被“消费完了”，无法再被操作。所以termainal操作必定是流的最后一个操作，执行了该操作才会对流进行真正的遍历。
这里要注意的是多个Intermediate并不是多次for循环，而是将该操作先放到一个集合中，在terminal操作中几种处理。
short-circuiting：
对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。
3.流的使用详解
流的创建：
public static void main(String[] args) {
// 单个元素
Stream stream = Stream.of("a", "b", "c");
// 数组
String[] arr = new String[]{"a", "b", "c"};
stream = Arrays.stream(arr);
stream = Stream.of(arr);
// 集合
List list = Arrays.asList(arr);
stream = list.stream();
/**
* Stream提供了IntStream、LongStream、DoubleStream来专门处理基本数值类型
* 当然也可以使用Stream、Stream、Stream来处理，但是
* 自动装箱和拆箱会额外耗费性能
*/
IntStream.of(1,2,3).forEach(System.out::println);
} 流的转换：
public static void main(String[] args) {
Stream stream = Arrays.stream(new String[]{"a","b","c"});
// 数组
String[] arr1 = stream.toArray(String[]::new);
// 集合
List list1 = stream.collect(Collectors.toList());
ArrayList list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set collect = stream.collect(Collectors.toSet());
Stack stack = stream.collect(Collectors.toCollection(Stack::new));
// String
String string = stream.collect(Collectors.joining()).toString();
} 流的操作：
Intermediate：
map（mapToInt,flatMap等）、filter、distinct、sorted、peek、limit、skip、parallel、sequential、unordered
Terminal：
forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
short-circuiting：
anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit
map:
/**
* 将下列集合中的所有数字乘以10,并得到新集合[1, 20, 63, 58, 185, 60, 59, 20]
*/
@Test
public void show4(){
Integer[] nums = {1, 20, 63, 58, 185, 60, 59, 20};
Integer[] integers = Arrays.stream(nums).map(i -> i * 10).toArray(Integer[]::new);
Arrays.stream(integers).forEach(System.out::println);
}
从上面的例子可以看出，map是1对1映射，将每个输入的元素都按照规则转换成输出的元素。有些场景需要一对多映射，那么就可以使用flatMap
@Test
public void test14(){
Stream> inputStream = Stream.of(
Arrays.asList(1),
Arrays.asList(2, 3),
Arrays.asList(4, 5, 6)
);
Stream outputStream = inputStream.
flatMap((childList) -> childList.stream());
List collect = outputStream.collect(Collectors.toList());
}
filter：
filter 对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。
/**
* 将数组或者集合中不小于50的数输出出来
*/
@Test
public void show() {
int[] a = {1, 20, 63, 58, 185, 60, 59, 20};
Arrays.stream(a).filter(value -> {return value>=50;}).forEach(System.out::print);
}
forEach:
forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。
/**
* 输出下列集合中相同的字符串
*/
@Test
public void show3(){
String[] s1 = {"qwer", "asdf", "zxcv", "fgh", "jum", "rfv"};
String[] s2 = {"edc", "zse", "asdf", "zxcv", "yhnj"};
Arrays.stream(s1).forEach(x->{Arrays.stream(s2).filter(y->{return x.equals(y);}).forEach(System.out::println);});
}
reduce：
这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。
@Test
public void test15() {
// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
}limit/skip：
limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来）。
/**
* 取出下列集合中的第3到7个值，加上5，得到新的集合[1, 20, 63, 58, 185, 60, 59, 20]
*/
@Test
public void show5() {
Integer[] nums = {1, 20, 63, 58, 185, 60, 59, 20};
Integer[] integers = Arrays.stream(nums).skip(2).limit(5).map(i -> i + 5).toArray(Integer[]::new);
System.out.println(Arrays.toString(integers));
}sorted：
对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。
/**
* 将下列名字转换为大写，再排序输出（"Fred Edwards", "Anna Cox", "Deborah Patterson", "Ruth Torres", "Shawn Powell"）
*/
@Test
public void test10() {
String[] str = {"Fred Edwards", "Anna Cox", "Deborah Patterson", "Ruth Torres", "Shawn Powell"};
Arrays.stream(str).map(p -> p.toUpperCase()).sorted().forEach(System.out::println);
}min/max/distinct：
min 和 max 的功能也可以通过对 Stream 元素先排序，再 findFirst 来实现，但前者的性能会更好，为 O(n)，而 sorted 的成本是 O(n log n)。同时它们作为特殊的 reduce 方法被独立出来也是因为求最大最小值是很常见的操作。
/**
* 输出下列集合的最小值[1, 20, 63, 58, 185, 60, 59, 20]
*/
@Test
public void show6() {
int[] nums = {1, 20, 63, 58, 185, 60, 59, 20};
System.out.println(Arrays.stream(nums).min().getAsInt());
}Match：
allMatch： Stream中所有元素全部匹配才返回true
anyMatch：Stream中只要一个元素匹配就返回true
noMatch： Stream中没有一个元素匹配才返回true
/**
* 判断下列数组或集合中的数是否全部大于50
*/
@Test
public void show2() {
int[] a = {1, 20, 63, 58, 185, 60, 59, 20};
boolean b = Arrays.stream(a).allMatch(value -> value > 50);
System.out.println(b);
}reduce:
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("s1");
list.add("s2");
list.add("s3");
list.add("s4");
// reduce会返回一个Optional对象
Optional reduce = list.stream().reduce((s, s2) -> s.concat(s2.toUpperCase()));
reduce.ifPresent(System.out::println);//s1S2S3S4
} 并行stream：使用stream()方法获得的流是串行操作，如果考虑性能可以使用并行parallelStream
public static void main(String[] args) {
int max = 1000000;
List list = new ArrayList<>();
for (int i = 0; i < max; i++) {
list.add(UUID.randomUUID().toString());
}
long begin = System.currentTimeMillis();
//long count = list.stream().sorted().count();//625ms
long count = list.parallelStream().sorted().count();//375ms
long end = System.currentTimeMillis();
System.out.println(String.format("cost %dms",end - begin));
}