一、Stream API 说明
Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。
Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式
二、为何使用Stream API
实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。
Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算
三、什么是 Stream
它是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“集合讲的是数据，Stream讲的是计算！
注意：
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
四、Stream 的操作三个步骤
1- 创建 Stream
一个数据源（如：集合、数组），获取一个流
2- 中间操作
一个中间操作链，对数据源的数据进行处理
3- 终止操作( 终端操作)
一旦执行终止操作，就执行中间操作链，并产生结果。之后不会再被使用
（4.1）创建Stream的方式
（一）、通过集合来创建 Stream
Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
- default Stream<E> stream() : 返回一个顺序流
- default Stream<E> parallelStream() : 返回一个并行流
//可以通过 Collection 系列集合提供的 stream() 顺序流
List<String> list=Arrays.asList("张三","李飞","刘霞","陈博");
Stream<String> stream1=list.stream();
stream1.forEach(System.out::println);
System.out.println("*****************************");
// 可以通过 Collection 系列集合提供的 parallelStream() 并行流
Stream<String> stream2=list.parallelStream();
stream2.forEach(System.out::println); 
（二）、通过数组来创建 Stream
Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
static <T> Stream<T> stream(T[] array): 返回一个流
重载形式，能够处理对应基本类型的数组：
public static IntStream stream(int[] array)
public static LongStream stream(long[] array)
public static DoubleStream stream(double[] array)
注意：学生类（姓名，年龄）自己创建。
//通过Arrays中的静态方法 stream()获取一个数组流
Student[] students = new Student[3];
students[0]=new Student("mike",18);
students[1]=new Student("john",20);
students[2]=new Student("peter",16);
Stream<Student> stream = Arrays.stream(students);
stream.forEach(System.out::println);
（三）、通过Stream的of来创建 Stream
可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。
public static<T> Stream<T> of(T... values) : 返回一个流
Student[] students = new Student[3];
students[0]=new Student("mike",18);
students[1]=new Student("john",20);
students[2]=new Student("peter",16);
//通过Stream的静态方法 of()
Stream<Student> stream=Stream.of(students);
stream.forEach(System.out::println);
（四）、通过无限流来创建 Stream
可以使用静态方法 Stream.iterate() 和 Stream.generate(),创建无限流。
迭代
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
生成
public static<T> Stream<T> generate(Supplier<T> s)
// Stream.iterate 创建
Stream stream4 = Stream.iterate(10, i -> i+10);
stream4.limit(5).forEach(System.out::println);
System.out.println("**************************");
// Stream.generate 创建
Stream stream3 = Stream.generate(()-> 88);
stream3.limit(5).forEach(System.out::println); 
（4.2）中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
1-筛选和切片
//使用filter过滤集合中的奇数
List<Integer> list = Arrays.asList(89,15,88,19,33,24,30);
list.stream().filter(num->num%2!=0).forEach(System.out::println);
System.out.println("---------------------");
//使用distinct去掉重复的字符串
List<String> list1 = Arrays.asList("boy","happy","girl","happy","boy","boy");
list1.stream().distinct().forEach(System.out::println );
System.out.println("---------------------");
//使用skip,limit跳过前两个的前三个元素
List<Integer> list2 = Arrays.asList(10,20,30,40,50,60,70,80);
list2.stream().skip(2).limit(3).forEach(System.out::println);
int n=3;
Stream<Integer> integerStream = Stream.of(10, 20, 30, 40, 50, 60);
//跳过前n个（非负）元素，返回剩下的流，有可能为空流。
integerStream.skip(n).forEach(integer -> System.out.println("num = " + integer));
System.out.println("--------------------------");
n=3;
Stream<Integer> st2 = Stream.of(10, 20, 30, 40, 50, 60);
// 当 n < 0 时直接抛出了 IllegalArgumentException 异常。
// 当 n=0 时，返回一个空流。
// 当 n=3 时，打印了 前3个元素
// 当 n=7 时，打印了所有元素
st2.limit(n).forEach(integer -> System.out.println("num = " + integer));
skip与limit区别：
skip必须时刻监测流中元素的状态。才能判断是否需要丢弃。所以skip属于状态作。
limit只关心截取的是不是其参数maxsize（最大区间值），其它毫不关心。一旦达到就立马中断操作返回流。所以limit属于一个中断操作。
2-映射
// 在Java 8 中如何使用Stream将List转换为Map，使用Collectors.toMap方法进行转换。
//1、指定key-value，value是对象中的某个属性值。
List<Student> list=Arrays.asList(new Student("mike",22),new Student("zhang",20),new Student("john",21));
Map<String,Integer> stuMap=list.stream().collect(Collectors.toMap(Student::getName,Student::getAge));
System.out.println(stuMap);
// 2、指定key-value，value是对象本身，Student->Student 是一个返回本身的lambda表达式
Map<String,Student> stuMap2=list.stream().collect(Collectors.toMap(Student::getName,Student->Student));
System.out.println(stuMap2);
// 3、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身 (同2)
Map<String,Student> stuMap3=list.stream().collect(Collectors.toMap(Student::getName, Function.identity()));
System.out.println(stuMap3);
//计算所有平均年龄
System.out.println(list.stream().mapToInt(Student::getAge).average().getAsDouble());
3-排序
System.out.println("---Natural Sorting by Name---");
List<Student> list= Arrays.asList(new Student("mike",22),new Student("zhang",20),new Student("john",21));
list.forEach(s -> System.out.println(" Name: "+s.getName()+", Age:"+s.getAge()));
System.out.println("\n---Sorting using Comparator by Age---");
list=list.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
list.forEach(s -> System.out.println(" Name: "+s.getName()+", Age:"+s.getAge()));
System.out.println("\n---Sorting using Comparator by Age with reverse order---");
list=list.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
list.forEach(s -> System.out.println(" Name: "+s.getName()+", Age:"+s.getAge()));
（4.3）Stream 的终止操作
注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google用它来进行网络搜索而出名。
Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。
另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，
具体方法与实例如下表：
354
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
