StreamAPI

一、Stream特点

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，负责存储数据，Stream流讲的是计算，负责处理数据！”

注意：

①Stream 自己不会存储元素。
②Stream 不会改变源对象。每次处理都会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

二、Stream操作的步骤

1- 创建 Stream：通过一个数据源（如：集合、数组），获取一个流

2- 中间操作：每次处理都会返回一个持有结果的新Stream，即中间操作的方法返回值仍然是Stream类型的对象，因此中间操作可以是个操作链（返回值类型是Stream类型的可以一直使用.方法操作），可对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。

3- 终止操作：终止操作的方法返回值类型就不再是Stream了，因此一旦执行终止操作，就结束整个Stream操作了。一旦执行终止操作，就执行中间操作链，最终产生结果并结束Stream。

案例分析：

 @Testpublic void test1(){//1、创建Stream，指定数据源来创建StreamArrayList list = new ArrayList<>();list.add("hello");list.add("java");list.add("hi");list.add("heihei");Stream stream = list.stream();//2、加工处理//假设我要处理的要求：把里面所有的e字母，修改为a//Function 的抽象方法  R apply(T t)stream = stream.map(s-> s.replace('e','a'));//假设我要处理的要求：筛选出包含a字母的单词//Predicate接口   boolean test(T t)stream = stream.filter(s -> s.contains("a"));//处理，打印所有包含"a"字母的单词//Consumer 的抽象方法  void accept(T t)stream = stream.peek( s -> System.out.println(s));//3、结束处理//统计满足条件的单词的个数
//         long count = stream.count();//没有这一步，前面的加工处理不执行
//        System.out.println("count = " + count);System.out.println("list = " + list);//不会修改数据源}

没有开启3、结束处理步骤时的运行结果：

开启之后的运行结果：

三、创建StreamAPI

1、创建 Stream方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

• public default Stream stream() : 返回一个顺序流

• public default Stream parallelStream() : 返回一个并行流

Stream stream = list.stream();

2、创建 Stream方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

• public static Stream stream(T[] array): 返回一个流

String[] arr = {“hello”,“world”,“java”};
Stream stream = Arrays.stream(arr);

3、创建 Stream方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

• public static Stream of(T… values) : 返回一个顺序流

Stream stringStream = Stream.of(“hello”, “world”, “java”);

4、创建 Stream方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

• public static Stream iterate(final T seed, final UnaryOperator f):返回一个无限流
• public static Stream generate(Supplier s) ：返回一个无限流

@Testpublic void test4(){//Supplier 的抽象方法  T get()Stream stream = Stream.generate(() -> Math.random());//结束Stream//Consumer 的抽象方法  void accept(T t)stream.forEach(t-> System.out.println(t));}@Testpublic void test5(){//Stream iterate(final T seed, final UnaryOperator f)//seed：种子//UnaryOperator： T apply(T t)
//       Stream stream =  Stream.iterate(1, t -> t+2);Stream stream =  Stream.iterate(1, t -> {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}return t+2;});//结束Stream//Consumer 的抽象方法  void accept(T t)stream.forEach(System.out::println);}
}

四、中间操作API

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

 /*需求：给你一组单词，统计里面使用了几个字母，并找出这些字母*//* Stream map(Function mapper);T类型->R类型对象 Stream flatMap(Function> mapper);T类型->Stream流*/Set set = Stream.of("hello", "java", "world", "xiaoyu")  //把所有单词的每一个字母取出来.flatMap(s -> Arrays.stream(s.split("|"))).collect(Collectors.toSet());System.out.println("字母有："+set);System.out.println("个数：" + set.size());/*字母有：[a, d, e, h, i, j, l, o, r, u, v, w, x, y]个数：14*/

案例：

    @Testpublic void test10(){//找出最老的3个员工，年龄最大的3个员工ArrayList list = new ArrayList<>();list.add(new Employee(1,"张三",23,15000));list.add(new Employee(2,"李四",24,14000));list.add(new Employee(3,"王五",25,18000));list.add(new Employee(4,"赵六",22,12000));list.add(new Employee(5,"陈前",29,12000));list.add(new Employee(6,"林上清",27,12000));list.add(new Employee(7,"昆昆",27,12000));//年龄第3名的员工，年龄值不能重复//思路：先找出年龄值是第3的值，然后再找员工//Stream 	mapToInt(ToIntFunction f)//ToIntFunction int applyAsInt(T value);OptionalInt ageOption = list.stream().sorted((t1,t2)->t2.getAge()-t1.getAge()).mapToInt(emp -> emp.getAge()).distinct().skip(2).findFirst();System.out.println("age = " + ageOption);list.stream().filter(emp -> emp.getAge() == ageOption.getAsInt()).forEach(t-> System.out.println(t));}

五、终结操作API

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void。流进行了终止操作后，不能再次使用。

        Stream stream = Stream.of(1, 2, 3, 5, 7, 9);//判断stream中的所有数据，是否都满足 偶数的要求//allMatch(Predicate predicate)//Predicate boolean test(T t)boolean result = stream.allMatch(num -> num % 2 == 0);//判断stream中的所有数据，是否有数字满足 偶数的要求//anyMatch(Predicate predicate)//Predicate boolean test(T t)boolean result = stream.anyMatch(num -> num % 2 == 0);}//判断stream中的所有数据，是否都不满足 偶数的要求//noneMatch(Predicate predicate)//Predicate boolean test(T t)boolean result = stream.noneMatch(num -> num % 2 == 0);//获取流中第一个元素Optional first = stream.findFirst();//加工处理一下，筛选出所有的偶数//Stream filter(Predicate predicate);//Predicate boolean test(T t)stream = stream.filter(num -> num%2==0);//统计流中的元素个数long count = stream.count();//找出流中的最大值和最小值//Comparator int compare(T t1 ,T t2)Optional max = stream.max((t1, t2) -> t1-t2);Optional min = stream.min((t1, t2) -> t1 - t2);//遍历流中的数据//  void forEach(Consumer action);//Consumer 的抽象方法  void accept(T t)stream.forEach(t-> System.out.println(t));//使用reduce方法找出最大值，不用max方法//Optional reduce(BinaryOperator accumulator);//BinaryOperator T apply(T t1, T t2)Optional max = stream.reduce((t1, t2) -> t1 > t2 ? t1 : t2);//把流中的元素值累加起来//Optional reduce(BinaryOperator accumulator);//BinaryOperator T apply(T t1, T t2)final Optional sum = stream.reduce((t1, t2) -> t1 + t2);//筛选出所有的偶数，放到一个List集合中//中间处理//Stream filter(Predicate predicate);//Predicate boolean test(T t)stream = stream.filter(t->t%2==0);//收集这些元素到List中List list = stream.collect(Collectors.toList());//筛选出所有的偶数，放到一个Set集合中//中间处理//Stream filter(Predicate predicate);//Predicate boolean test(T t)stream = stream.filter(t->t%2==0);Set set = stream.collect(Collectors.toSet());