Java Stream

1. 流 (Stream)是什么

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据，流讲的是计算！ ”

注意：

• Stream 自己不会存储元素。
• Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
• Stream 只能被“消费”一次，一旦遍历过就会失效。就像容器的迭代器那样，想要再次遍历必须重新生成一个新的Stream

2. Stream 操作实例

取出所有大于18岁人的姓名，按字典排序，并输出到控制台

public class StreamDemo {


    private static List<Person> persons = Arrays.asList(
            new Person("CJK", 19, "女"),
            new Person("BODUO", 20, "女"),
            new Person("JZ", 21, "女"),
            new Person("anglebabby", 18, "女"),
            new Person("huangxiaoming", 5, "男"),
            new Person("ROY", 18, "男")
    );

    public static void main(String[] args) throws IOException {
        persons.stream().filter(x -> x.getAge() >= 18).map(Person::getName).sorted().forEach(System.out::println);
    }
}

BODUO
CJK
JZ
ROY
anglebabby

3. Stream 的操作三个步骤

1. 创建 Stream 一个数据源（如：集合、数组），获取一个流
2. 中间操作 一个中间操作链，对数据源的数据进行处理
3. 终止操作(终端操作) 一个终止操作，执行中间操作链，并产生结果

4. 创建Steam

• Collection提供了两个方法 stream()与parallelStream()
• 通过Arrays中的stream()获取一个数组流
• 通过Stream 类中静态方法of()
• 创建无限流

public void test1(){
    //1. Collection 提供了两个方法  stream() 与 parallelStream()
    List<String> list = new ArrayList<>();
    Stream<String> stream = list.stream(); //获取一个顺序流
    Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

    //2. 通过 Arrays 中的 stream() 获取一个数组流
    Integer[] nums = new Integer[10];
    Stream<Integer> stream1 = Arrays.stream(nums);

    //3. 通过 Stream 类中静态方法 of()
    Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);
    
    //4. 创建无限流
    //迭代
    Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
    stream3.forEach(System.out::println);

    //生成
    Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
    stream4.forEach(System.out::println);
}

问题：

下面创建流(Stream)的方式哪些是正确的（多选） => C,D,E,F

A. Steam.newInstanceOf()

B. Collection.of()

C. Collection.stream() 或Collection.parallelStream()

D.Stream.of()

E.Stream.generate() 或 Stream.iterate()

F.Arrays.stream()

5. 中间操作

1. 筛选与切片
   • filter——接收 Lambda ， 从流中排除某些元素。
   • limit——截断流，使其元素不超过给定数量。
   • skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
   • distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
2. 映射

• map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
• flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

3. 排序

• sorted()——自然排序
• sorted(Comparator com)——定制排序

问题：

1. 有个数组Integer[] ary = {1,2,3,4,5,6,7,8,9,10} ，取出中间的第三到第五个元素

List<Integer> collect = Arrays.stream(ary).skip(2).limit(3).collect(Collectors.toList());

2. 有个数组Integer[] ary = {1,2,2,3,4,5,6,6,7,8,8,9,10}，取出里面的偶数，并去除重复

List<Integer> list = Arrays.stream(ary).filter(x -> x % 2 == 0).distinct().collect(Collectors.toList());

Set<Integer> integerSet = Arrays.stream(ary).filter(x -> x % 2 == 0).collect(Collectors.toSet());

3. 有个二维数组，要求把数组组合成一个一维数组，并排序（1，2，3，4，5……12）

Integer ary = {{3,8,4,7,5}, {9,1,6,2}, {0,10,12,11} };

Arrays.stream(ary).flatMap(item->Arrays.stream(item)).sorted().forEach(System.out::println);    

6. 终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是void 。

查找与匹配

接口	说明
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	迭代

问题：

Integer[] ary = {1,2,3,4,5,6,7,8,9,10}

1. 检查是否所有元素都小于10

boolean result1 = Arrays.stream(ary).allMatch(x -> x < 10);
System.out.println(result1);

2. 检查是否至少有一个元素小于2

boolean result2 = Arrays.stream(ary).anyMatch(x -> x < 2);
System.out.println(result2);

3. 检查是不是没一个元素大于10

boolean result3 = Arrays.stream(ary).noneMatch(x -> x > 2);
System.out.println(result3);

4. 返回第一个元素

Optional<Integer> first = Arrays.stream(ary).findFirst();
System.out.println(first.get());

5. ary 有多少个元素

long count = Arrays.stream(ary).count();
System.out.println(count);

6. 求ary里面最大值

Optional<Integer> max = Arrays.stream(ary).max(Integer::compareTo);
System.out.println(max.get());

7. 求ary里面最小值

Optional<Integer> min = Arrays.stream(ary).min(Integer::compareTo);
System.out.println(min.get());

8. 循环遍历打出ary 里面偶数

Arrays.stream(ary).filter(x -> x % 2 == 0).forEach(System.out::println);

7. 归约

reduce(T iden, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 T

reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 Optional<T>

问题：求所有人员学生的总分

Integer all = persons.stream().map(Person::getScore).reduce((integer, integer2) -> integer + integer2).get()

8. 收集

collect(Collector c)

将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

Collector接口中方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。

Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例

1 具体方法与实例如下：

• toList List 把流中元素收集到List

List<Person> emps= list.stream().collect(Collectors.toList());

• toSet Set 把流中元素收集到Set

Set<Person> emps= list.stream().collect(Collectors.toSet());

• toCollection Collection 把流中元素收集到创建的集合

Collection<Person> emps=list.stream().collect(Collectors.toCollection(ArrayList::new));

• counting Long 计算流中元素的个数

long count = list.stream().collect(Collectors.counting());

• summing Int Integer 对流中元素的整数属性求和

int total=list.stream().collect(Collectors.summingInt(Person::getAge));

• averaging Int Double 计算流中元素Integer属性的平均值

double avg= list.stream().collect(Collectors.averagingInt(Person::getAge));

• summarizingInt IntSummaryStatistics 收集流中Integer属性的统计值。如：平均值

Int SummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Person::getAge));

• joining String 连接流中每个字符串

String str= list.stream().map(Person::getName).collect(Collectors.joining());

• maxBy Optional 根据比较器选择最大值

Optional<Person> max= list.stream().collect(Collectors.maxBy(comparingInt(Person::getSalary)));

• minBy Optional 根据比较器选择最小值

Optional<Person> min = list.stream().collect(Collectors.minBy(comparingInt(Person::getSalary)));

• reducing 归约产生的类型 从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值

int total=list.stream().collect(Collectors.reducing(0, Person::getSalar, Integer::sum));

• collectingAndThen 转换函数返回的类型 包裹另一个收集器，对其结果转换函数

int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));

• groupingBy Map<K, List> 根据某属性值对流分组，属性为K，结果为V

Map<Person.Status,List<Person>> map= list.stream().collect(Collectors.groupingBy(Person::getStatus));

partitioningBy Map<Boolean, List<T>> 根据true或false进行分区

Map<Boolean,List<Person>>vd= list.stream().collect(Collectors.partitioningBy(Person::getManage));

2. 练习

Integer[] ary = {1,2,3,4,5,6,7,8,9,10}

1. 使用Collectors求ary的最大值

Optional<Integer> collect = Arrays.stream(ary).collect(Collectors.maxBy(Comparator.comparing(x -> x)));
        System.out.println(collect.get());

2. 使用Collectors求ary的平均值

IntSummaryStatistics collect1 = Arrays.stream(ary).collect(Collectors.summarizingInt(x -> x));
System.out.println(collect1.getAverage());

3. 使用Collectors.joining输出”1:2:3:4:5:6:7:8:9:10”

String collect2 = Arrays.stream(ary).map(x -> x.toString()).collect(Collectors.joining(":"));
System.out.println(collect2);

4. 使用Collectors.reducing求ary数组的总和

int total=Arrays.stream(ary).collect(Collectors.reducing(0, x->x, Integer::sum));
System.out.println(total);

5. 使用Collectors.counting求ary个数

Long collect3 = Arrays.stream(ary).collect(Collectors.counting());
System.out.println(collect3);

3. 问题：

1. 取出Person对象的所有名字，放到List集合中

List<String> collect2 = persons.stream().map(Person::getName).collect(Collectors.toList());

2. 求Person对象集合的分数的平均分、总分、最高分，最低分，分数的个数

IntSummaryStatistics collect = persons.stream().collect(Collectors.summarizingInt(Person::getScore));
System.out.println(collect);

3. 根据成绩分组，及格的放一组，不及格的放另外一组

Map<Boolean, List<Person>> collect1 = persons.stream().collect(Collectors.partitioningBy(person -> person.getScore() >= 60));
System.out.println(collect1);

4. WordCount

public static void main(String[] args) throws IOException {
    InputStream resourceAsStream = Person.class.getClassLoader().getResourceAsStream("aa.txt");
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resourceAsStream));
    bufferedReader.lines().flatMap(x->Stream.of(x.split(" "))).sorted().collect(Collectors.groupingBy(String::toString)).forEach((a,b)-> System.out.println(a+":"+b.size()));
    bufferedReader.close();
}