Stream流——对java集合运算和表达的高级抽象

一、什么是Stream

Stream流是一种对java集合运算和表达的高级抽象。Stream自己不会存储元素。
Stream不会改变源对象。相反，会返回一个持有结果的新Stream。
Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行。

二、Stream的操作三步骤

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

三、创建Stream

public class TestStreamAPI1 {
    public void test1(){
    // 1、可以通过Conllection系列集合提供的顺序流stream()或并行流parallelStream(
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        stream1 = list.parallelStream();

// 2、通过Arrays中的静态方法stream()获取数据流
        Integer ints[] = new Integer[10];
        Stream<Integer> stream2 = Arrays.stream(ints);

        Stream<String> stream3 = Stream.of("aa","bb");
        
        // 3、通过Stream类中的静态方法of()
        String str[] = new String[10];
        Stream<String> stream4 = Stream.of(str);
    }
}

四、Stream的中间操作

1、筛选和切片
filter

   List<Employee> emps = Arrays.asList(
            new Employee("张三", 18, 3333.33),
            new Employee("李四", 38, 4444.44),
            new Employee("王五", 50, 5555.55),
            new Employee("赵六", 16, 6666.66),
            new Employee("田七", 28, 7777.77) );

    Stream<Employee> stream = emps.stream()
            .filter(e->e.getAge()>30);
    stream.forEach(System.out::println);

limit
截断流，使其元素不超过给定数量

  emps.stream()
            .filter(e->e.getAge()>30)
            .limit(2)
            .forEach(System.out::println);

skip
跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。

emps.stream()
        .filter(e->e.getAge()>30)
        .skip(2)
        .forEach(System.out::println);

distinct
筛选，通过流所生产元素的hashCode()和equals()去除重复元素

emps.stream()
        .filter(e->e.getAge()>10)
        .distinct()
        .forEach(System.out::println);

2、排序
sorted(Comparable)-自然排序

List<String> list1 = Arrays.asList("cc", "aa", "bb", "ee", "dd");
list.stream().sorted().forEach(System.out::println);

sorted(Comparator)-定制排序
按年龄排序，年龄一样按姓名排序

 emps.stream()
                .sorted((e1,e2)->{
                    if(e1.getAge().equals(e2.getAge())){
                        return e1.getName().compareTo(e2.getName());
                    }else {
                        return e1.getAge().compareTo(e2.getAge());
                    }
                })
                .forEach(System.out::println);

五、Stream的终止操作

1、查找与匹配
allMatch-检查是否匹配所有元素
anyMatch-检查是否至少匹配一个元素
noneMatch-检查是否没有匹配所有元素
findFirst-返回第一个元素
findAny-返回当前流中的任意元素
count-返回流中元素的总个数
max-返回流中最大值
min-返回流中最小值

```java
        boolean b1 = emps.stream()
                .allMatch(e->e.getAge().equals(10));
        System.out.println(b1);

boolean b2 = emps.stream()
        .anyMatch(e->e.getAge().equals(10));
System.out.println(b2);

boolean b3 = emps.stream()
        .noneMatch(e->e.getAge().equals(10));
System.out.println(b3);

Optional<Employee> op1 = emps.stream()
        .sorted(Comparator.comparingInt(Employee::getAge))
        .findFirst();
System.out.println(op1.get().getAge());
Long count = emps.stream().count();

Optional<Employee> op2 = emps.stream()
        .max(Comparator.comparingInt(Employee::getAge));

Optional<Integer> op3 = emps.stream()
        .map(e-> e.getAge()).min(Integer::compareTo);

2、收集（了解）
收集-将流转换为其他形式，接收一个collector接口的实现，用于给Stream中元素做汇总的方法。

List<String> list3 =emps.stream().map(Employee::getName).collect(Collectors.toList());

Set<Integer> set = emps.stream().map(Employee::getAge).collect(Collectors.toSet());

Map<String,Integer> map = emps.stream().collect(Collectors.toMap(Employee::getName,Employee::getAge));

Long count = emps.stream().collect(Collectors.counting());

Double score = emps.stream().collect(Collectors.averagingDouble(Employee::getScore));

Double sum = emps.stream().collect(Collectors.summingDouble(Employee::getScore));
Optional<Employee> op = emps.stream()
 .collect(Collectors.maxBy((e1,e2)->Integer.compare(e1.getAge(),e2.getAge())));