Java8中有两大最为重要的改变，一个是Lambda表达式，另一个是Stream API。Stream API（java.util.stream)把真正的函数式编程风格引入到Java中，这是目前为止对Java最好的补充，因为Stream API可以极大的提高java程序员的生产力，让程序员写出高效、干净、简洁的代码。
StreamAPI： StreamAPI是用来处理数据，处理集合等容器中的数据，处理操作有：查询、筛选、删除、过滤、统计、映射等。 希望能够用类似于SQL语法的形式对Java内存中的数据进行处理。
SQL是对数据库中的数据进行处理。
Stream本身不负责存储数据，存储数据是用集合，数组等数据结构。 Stream只负责对数据进行处理、加工。
Stream的操作分为三步： 1、创建Stream：告知Stream数据的来源是哪里？ 2、加工处理：这个过程可以很多步 0~n 3、终结操作：收集结果 一旦终结就不能再加工了，如果要加工需要重新创建Stream。
Stream的特点： （1）Stream本身不负责存储数据，存储数据是用集合，数组等数据结构。 （2）Stream是不可变，一旦修改，就会产生新的Stream对象。Stream不会修改数据源的数据。 （3）Stream的操作是一个延迟操作。所有的操作都必须延迟到终结操作时，一起处理(不到最后一步不处理）。 示例：
@Test public void test01(){ ArrayList<Employee> list= new ArrayList<>(); list.add(new Employee(1,"张三")); list.add(new Employee(1,"张三")); Stream<Employee> stream = list.stream(); stream = stream.distinct();//处理，中间操作，去掉重复的元素 long count = stream.count();//统计个数 终结操作 System.out.println(count); System.out.println("over"); System.out.println("--------------------"); //重新遍历list //会发现list的数据还是两个，没有删除，说明Stream不会修改数据源的数据，只是统计去掉元素后元素的个数 for (Employee employee : list) { System.out.println(employee); } } } class Employee{ private int id; private String name; public Employee(int id, String name) { super(); this.id = id; this.name = name; } public Employee() { super(); } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Employee [id=" + id + ", name=" + name + "]"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + id; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { System.out.println("比较...."); if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Employee other = (Employee) obj; if (id != other.id) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; }重写了hascode和equals方法
运行结果over，说明走过最后的代码到最后，但是结果没显示equals被调用， 因为stream = stream.distinct()执行是处理，中间操作，是一个延迟操作，没有结束的时候，相当于还没执行，需要终结Stream，加代码
long count = stream.count();//统计个数 终结操作 System.out.println(count);再运行发现有调用equals方法
Stream接口： 实现类 IntStream DoubleStream LongStream …
一、创建Stream
1、方式一：通过集合创建 集合对象.stream() @Test public void test01(){ List<Integer> list = Arrays.asList(1,2,3,4,5); //JDK1.8中，Collection系列集合增加了方法 Stream<Integer> stream = list.stream(); } //Map中没有这个方法，因为Map里是键值对，遍历的话需要拿到key、value或者enry，Stream不能存在键值对 2、方式二：通过数组工具类Arrays Arrays.stream(数组对象) @Test public void test02(){ int[] arr = {1,2,3,4,5}; IntStream stream = Arrays.stream(arr); //int数组返回IntStream } @Test public void test03(){ String[] arr = {"hello","world"}; Stream<String> stream = Arrays.stream(arr); //返回泛型-String类型的 } 3、方式三：Stream接口的静态方法of方法，产生一个有限流 Stream.of(…) @Test public void test04(){ Stream<Integer> stream = Stream.of(1,2,3,4,5);//有限的数据，有限流 stream.forEach(System.out::println); } 4、方式四：Stream接口的静态方法，产生无限两种方式 （1）generate方法，产生无限流 （2）Stream<T> iterate(T seed, UnaryOperator<T> f) //方式一 @Test public void test05(){ Stream<Double> stream = Stream.generate(Math::random); stream.forEach(System.out::println); } //无限的数据，无限流无限输出产生的数据
//方式二 @Test public void test06(){ /* * Stream<T> iterate(T seed, UnaryOperator<T> f) * UnaryOperator接口，SAM接口，抽象方法： * * UnaryOperator<T> extends Function<T,T> * T apply(T t) */ Stream<Integer> stream = Stream.iterate(1, num -> num+=2); // stream = stream.limit(10);//限制循环10个数 stream.forEach(System.out::println); }无限流，n=1，n=n+2的无限循环
中间的加工操作 （1）filter(Predicate p)：过滤
@Test public void test01(){ //1、创建Stream Stream<Integer> stream = Stream.of(1,2,3,4,5,6); //2、加工处理 //过滤：filter(Predicate p) //把里面的偶数拿出来 /* * filter(Predicate p) * Predicate是函数式接口，抽象方法：boolean test(T t) */ stream = stream.filter(t -> t%2==0); //流修改后需要重新接收，否则报错 //3、终结操作：例如：遍历 stream.forEach(System.out::println); }还可以把三个步骤连在一起写
@Test public void test02(){ Stream.of(1,2,3,4,5,6)//创建 .filter(t -> t%2==0)//过滤 .forEach(System.out::println);//遍历 }（2）distinct()：去重
@Test public void test03(){ Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5) .distinct() .forEach(System.out::println); }（3）limit(long maxSize)：取有限的几个
@Test public void test04(){ Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5) .limit(3) .forEach(System.out::println); } @Test public void test05(){ Stream.of(1,2,2,3,3,4,4,5,2,3,4,5,6,7) .distinct() //(1,2,3,4,5,6,7) .filter(t -> t%2!=0) //(1,3,5,7) .limit(3) .forEach(System.out::println); }（4）skip(long n)：跳过n个
@Test public void test06(){ Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5) .skip(5) .forEach(System.out::println); } @Test public void test07(){ Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5) .skip(5)//6,2,2,3,3,4,4,5 .distinct()//6，3 .filter(t -> t%3==0) .forEach(System.out::println); }（5）peek(Consumer action) 接收Lambda表达式，对流中的每个数据执行Lambda体操作
@Test public void test08(){ long count = Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5) .distinct() .peek(System.out::println) //打印 //Consumer接口的抽象方法 void accept(T t) //这是中间操作，还不能打印出来，没有终止是不执行的 .count();//终止 统计 System.out.println("count="+count); }（6）sorted()：排序，按照自然排序 sorted(Comparator com)：排序，按照定制排序
//定制排序 @Test public void test09(){ //希望能够找出前三个最大值，前三名最大的，不重复 Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54) .distinct() .sorted() .limit(3) .forEach(System.out::println); }输出最小的三个数
//定制排序 @Test public void test09(){ //希望能够找出前三个最大值，前三名最大的，不重复 Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54) .distinct() .sorted((t1,t2) -> -Integer.compare(t1, t2))//Comparator接口 int compare(T t1, T t2) .limit(3) .forEach(System.out::println); } //Integer前加一个负号，不然返回的是最小的前三个数 //因为加了一个负号，不能再优化（7）map(Function f)：接收Lambda表达式，对流中的每个数据，执行Lambda体操作，返回新的数据构成新的流
@Test public void test10(){ Stream.of(1,2,3,4,5) .map(t -> t+=1)//Function<T,R>接口抽象方法 R apply(T t) .forEach(System.out::println); }每个数加了1
//将字符串变为大写 @Test public void test11(){ String[] arr = {"hello","world","java"}; Arrays.stream(arr) .map(t->t.toUpperCase()) .forEach(System.out::println); }（8）flatMap(Function f)
map(Function<? super T,? extends R> mapper) //map操作流中的把T对象变成R对象，由R对象构成新的流 flatMap(Function<? super T,? extends Stream<? extends R>> mapper) //flatMap把流中的数据T对象压扁变成一个Stream，然后把一个个的Stream最后再合成一个大的Stream @Test public void test12(){ String[] arr = {"hello","world","java"}; Stream<String> flatMap = Arrays.stream(arr) .flatMap(t -> Stream.of(t.split("|")));//Function<T,R>接口抽象方法 R apply(T t) 现在的R是一个Stream flatMap.forEach(System.out::println); }拆分成一个一个的，再合成一个大的Stream
创建：一步 中间：0~n步 终结：一步
三、终结操作 1、void forEach(Consumer )：遍历流中的数据（不一定是打印）
@Test public void test01(){ Stream.of(1,2,3,4,5) .forEach(System.out::println); }2、long count()：统计个数**
@Test public void test02(){ long count = Stream.of(1,2,3,4,5) .count(); System.out.println("count = " + count); }3、boolean allMatch(Predicate p)：是否全部 满足xx条件 boolean anyMatch(Predicate p)：是否有一个满足xx条件 boolean noneMatch(Predicate p)：是否全部都不满足xx条件
@Test //判断是否都是奇数 public void test03(){ boolean result = Stream.of(1,3,5,7,9) .allMatch(t -> t%2!=0); System.out.println(result); } //判断是否有满足偶数的 @Test public void test04(){ boolean result = Stream.of(1,3,5,7,9，6) .anyMatch(t -> t%2==0); System.out.println(result); }4、 Optional findFirst()：返回第一个 Optional findAny()：返回任意一个
@Test public void test08(){ Optional<Integer> opt = Stream.of(1,3,5,7,9).findFirst(); System.out.println(opt); }返回的是Optional
@Test public void test09(){ Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9) .filter(t -> t%3==0) .findFirst(); System.out.println(opt); } @Test public void test09(){ Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9) .filter(t -> t%3==0) .findAny(); System.out.println(opt); }若是稳定的流，findAny()默认返回的值和findFirst()一样，若是无限流、平行流等不稳定的流，每次返回的结果不一样，若是稳定的流，一般用findFirst()代替findAny(）
//若是结果为空的 @Test public void test10(){ Optional<Integer> opt = Stream.of(1,2,4,5,7,8) .filter(t -> t%3==0) .findFirst(); System.out.println(opt); } //没有3的倍数，返回Optional.empty,不会是null，这就是Optional存在的意义，取代了原来的空指针异常的方式的处理，Optional不返回null，返回Optional.empty没有3的倍数，返回Optional.empty,不会是null，这就是Optional存在的意义，取代了原来的空指针异常的方式的处理，Optional不返回null，返回Optional.empty
5、Optional max(Comparator c)：找出最大的 Optional min(Comparator c) ：找出最小的
@Test public void test11(){ Optional<Integer> max = Stream.of(1,2,4,5,7,8) .max((t1,t2) -> Integer.compare(t1, t2)); System.out.println(max); }返回的也是一个包装起来的值
6、 T reduce(T iden, BinaryOperator b) 通过反复的运算，留下最后一个结果 Optional reduce(BinaryOperator b)
@Test public void test12(){ Integer reduce = Stream.of(1,2,4,5,7,8) .reduce(0, (t1,t2) -> t1+t2);//BinaryOperator接口 T apply(T t1, T t2) System.out.println(reduce); }运算过程：0相当于起点，再将(1,2,4,5,7,8)累加
@Test public void test12(){ Integer reduce = Stream.of(1,2,4,5,7,8) .reduce(0, (t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口 T apply(T t1, T t2) System.out.println(reduce); }两两比较，大的留下
//reduce重载的方法 @Test public void test13(){ Optional<Integer> reduce = Stream.of(1,2,4,5,7,8) .reduce((t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口 T apply(T t1, T t2) System.out.println(reduce); }7、R collect(Collector c)：把流中的数据最后都收集到一起（可能收集到集合里、数组里等，都有可能）
//把偶数收集过来 @Test public void test14(){ List<Integer> list = Stream.of(1,2,4,5,7,8) .filter(t -> t%2==0) .collect(Collectors.toList()); //还有Collectors.toSet()、Collectors.toMap()等 System.out.println(list); }Collector接口 BiConsumer 抽象方法 void accept(R r,T t)
案例：
class Student{ private String name; private int age; public Student(String name, int age) { super(); this.name = name; this.age = age; } public Student() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; } } @Test public void test1(){ ArrayList<Student> list = new ArrayList<>(); list.add(new Student("张三", 23)); //... //取出流中第一个年龄大于30岁的学生 //返回的是Optional Optional<Student> opt = list.stream() .filter(s -> s.getAge()>30) .findFirst();//这步返回的是Optional.empty,若是没有Optional,返回的是null，若是null，下一步操作打印学生的年龄， //System.out.println("学生的年龄：" + stu.getAge());会报空指针异常，为了避免空指针异常，就得加各种判断，！null的判断，Optional类可以避免空指针异常 //打印该学生的年龄 Student stu = opt.orElse(new Student()); System.out.println("学生的年龄：" + stu.getAge()); } //Optional类得到null，初始化一个student，返回它的默认值0Optional类最开始就是为了解决和避免空指针异常的处理、判断这些
Optional实际上是个容器，它是一个装一个对象的容器。这个对象可能是个空，可能是非空。 数组和集合是装多个对象的容器。
1、创建Optional对象的方法：（没有构造器，构造器私有化了） （1）Optional.of(xx); 只能装非空对象,不然会报错 （2）Optional.ofNullable(x); 装可以是null的对象 （3）Optional empty() 直接返回一个空箱子对象 @Test public void test2(){ String str = "hello"; Optional<String> opt = Optional.of(str); System.out.println(opt); } @Test public void test3(){ String str = null; Optional<String> opt = Optional.ofNullable(str); System.out.println(opt); } 2、如何取出Optional容器中的对象（将装好的对象拿出来） （1）get() 必须配合of(xx)使用，因为这里面的对象不能是null，否则会报没有这样的值存在（NO value present） @Test public void test4(){ String str = "hello"; Optional<String> opt = Optional.of(str); String string = opt.get(); System.out.println(string); }若是容器里是null
@Test public void test5(){ String str = null; Optional<String> opt = Optional.ofNullable(str); // System.out.println(opt.get());//java.util.NoSuchElementException: No value present }会报错java.util.NoSuchElementException: No value present
（2）orElse(T other) 如果Optional容器中的对象是空的，用other代替
@Test public void test6(){ String str = "null"; Optional<String> opt = Optional.ofNullable(str); String string = opt.orElse("atguigu"); //若是容器里是空的，返回atguigu System.out.println(string); } @Test public void test6(){ String str = "hello"; Optional<String> opt = Optional.ofNullable(str); String string = opt.orElse("atguigu"); System.out.println(string); }若是容器非空，返回容器里的值
（3）orElseGet(Supplier<? extends T> other) 如果Optional容器中的对象是空的，用other这个供给型接口提供的对象代替
@Test public void test7(){ String str = hello; Optional<String> opt = Optional.ofNullable(str); String string = opt.orElseGet(String::new); System.out.println(string); }若是str为null
@Test public void test7(){ String str = null; Optional<String> opt = Optional.ofNullable(str); String string = opt.orElseGet(String::new); System.out.println(string); }返回空字符串，不会报错
（4）orElseThrow(Supplier<? extends X> exceptionSupplier) （容器里没有值，可以用自定义异常）
@Test public void test8(){ String str = null; Optional<String> opt = Optional.ofNullable(str); String string = opt.orElseThrow(()->new RuntimeException("值不存在")); System.out.println(string); } 3、其他操作 Optional filter(Predicate<? super T> predicate) @Test public void test9(){ String str = "hello"; Optional<String> opt = Optional.ofNullable(str); Optional<String> opt2 = opt.filter(s->s.length()>5);//长度大于5就留下，否则不要 System.out.println(opt2); }不满足返回Optional.empty
