Java8——Stream流

亦凉 2021-09-18 05:36 359阅读 0赞

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

`Stream`操作的三个步骤：

*  创建Stream
 *  中间操作
 *  终止操作

## 一、获取stream的四种方式 ##

1.  通过`collection`系列集合的`stream()`或`parallelStream()`获取。

@Test
    void test11(){ 
        List<String> list = new ArrayList<>();
        Stream<String> stringStream = list.stream();
    }

1.  通过`Arrays`中的静态方法`stream()`获取数组流。

@Test
    void test11(){ 
        Person[] person = new Person[10];
        Arrays.stream(person);
    }

1.  通过`Stream`中的静态方法`of()`。

@Test
    void test11(){ 
        Stream<String> stream = Stream.of("a", "b", "c");
    }

1.  创建无限流

/** * 迭代 */
    @Test
    void test11(){ 
        Stream<Integer> integerStream = Stream.iterate(0, x -> x + 2);
    }

/** * 生成 */
    @Test
    void test11(){ 
        Stream.generate(() -> Math.random());
    }

## 二、中间操作 ##

中间操作不会执行任何操作，只有终止操作才会一次性输出全部值，即“惰性求值”。

### 2.1 筛选与切片 ###

*  `filter`——接收`lamdba`，从流中排除某些元素

@Test
    void test12(){ 
        List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20)
        );
        // 中间操作
        Stream<Person> personStream = personList.stream()
            .filter(e -> e.getAge() > 18);
        // 终止操作
        personStream.forEach(System.out::println);
    }

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

@Test
    void test12(){ 
        
        List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20)
        );
        personList.stream()
            .limit(1)
            .forEach(System.out::println);
    }

*  `skip(n)`——跳过元素，返回一个扔掉前n个元素的流，若不足n个，则返回一个空流。与l`imit(n)`互补。

@Test
    void test12(){ 
        
        List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20)
        );
        personList.stream()
            .skip(1)
            .forEach(System.out::println);
    }

*  `distinct`——筛选，通过生成元素的`hashCode()`和`equals()`，去除重复元素。

@Test
    void test12(){ 
        
        List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20),
            new Person("Java旅途",20)
        );
        personList.stream()
            .distinct()
            .forEach(System.out::println);
    }

**注意：使用`distinct`的时候需要重写实体的`hashCode()`和`equals()`方法。**

### 2.2 映射 ###

*  `map`——接收`lamdba`，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

/** * 获取personList的所有name */
    @Test
    void test13(){ 
        List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20),
            new Person("Java旅途",20)
        );
        personList.stream()
            .map(Person::getName)
            .forEach(System.out::println);
    }

*  `flatMap`——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流生成一个流。

// 将字符串转换为字符，并将字符放进list返回
    static Stream<Character> filterCharcter(String string){ 
    
        List<Character> list = new ArrayList<>();
        for (Character ch : string.toCharArray()){ 
            list.add(ch);
        }
        return list.stream();
    }

@Test
    void test13(){ 
        List<String> list = Arrays.asList("aaa","bbb","ccc");
    
        list.stream()
            .flatMap(LamdbaApplicationTests::filterCharcter)
            .forEach(System.out::println);
    }

### 2.3 排序 ###

*  `sorted()`——自然排序（comparable）
 *  `sorted(comparator com)`——定制排序（comparator ）

/** * 定制排序，e1和e2按age排序，age一样按name排 */
    @Test
    void test14(){ 
        List<Person> personList = Arrays.asList(
                new Person("Java旅途",18),
                new Person("Java旅途",20)
        );
        personList.stream()
            .sorted((e1,e2) -> { 
                if(e1.getAge() == e2.getAge()){ 
                    return e1.getName().compareTo(e2.getName());
                }else{ 
                    return e1.getAge()+"".compareTo(e2.getAge()+"");
                }
            }).forEach(System.out::println);
    }

## 三、终止操作 ##

### 3.1 查找与匹配 ###

完善一下`Person`类

@Data
    public class Person implements Serializable { 
        private static final long serialVersionUID = -7008474395345458049L;
    
        private String name;
        private int age;
        private Status status;
        
        public Person() { 
        }
        public Person(String name, int age) { 
            this.name = name;
            this.age = age;
        }
        public Person(String name, int age, Status status) { 
            this.name = name;
            this.age = age;
            this.status = status;
        }
        public enum Status { 
            FRER,
            BUSY;
        }
    }

*  `allMatch`——检查是否匹配所有元素

/** * 是否所有元素都是Fire状态，是返回true */
    @Test
    void test15(){ 
        List<Person> personList1 = Arrays.asList(
            new Person("Java旅途",18, Person.Status.FRER),
            new Person("Java旅途",20, Person.Status.BUSY)
        );
        boolean b = personList1.stream()
            .allMatch(e -> e.getStatus().equals(Person.Status.FRER));
        System.out.println(b);
    }

*  `anyMatch`——检查是否至少匹配一个元素

@Test
    void test15(){ 
        List<Person> personList1 = Arrays.asList(
            new Person("Java旅途",18, Person.Status.FRER),
            new Person("Java旅途",20, Person.Status.BUSY)
        );
        boolean b = personList1.stream()
            .anyMatch(e -> e.getStatus().equals(Person.Status.FRER));
        System.out.println(b);
    }

*  `noneMatch`——检查是否所有元素都不匹配

@Test
    void test15(){ 
        List<Person> personList1 = Arrays.asList(
            new Person("Java旅途",18, Person.Status.FRER),
            new Person("Java旅途",20, Person.Status.BUSY)
        );
        boolean b = personList1.stream()
            .noneMatch(e -> e.getStatus().equals(Person.Status.FRER));
        System.out.println(b);
    }

*  `findFirst`——返回第一个元素

@Test
    void test15(){ 
        List<Person> personList1 = Arrays.asList(
            new Person("Java旅途",18, Person.Status.FRER),
            new Person("Java旅途",20, Person.Status.BUSY)
        );
        Optional b = personList1.stream()
            .findFirst();
        System.out.println(b.get());
    }

*  `findAny`——返回当前流中的任意元素

*  `count`——返回流中元素的总数
 *  `max`——返回流中最大值
 *  `min`——返回流中最小值

### 3.2 规约 ###

*  `reduce(T identity, BinaryOperator)`/`reduce(BinaryOperator)`——可以将流中元素反复结合起来，得到一个值。

/** * reduce 第一个参数是起始值 */
    @Test
    void test16(){ 
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream()
            			  .reduce(0,(x,y) -> x+y);
        System.out.println(sum);
        
        Optional<Integer> reduce = list.stream()
                    				   .reduce((x, y) -> x + y);
        System.out.println(reduce.get());
    }

### 3.3 收集 ###

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

/** * 取出名字放在一个list中 */
    @Test
    void test16(){ 
        List<Person> personList1 = Arrays.asList(
            new Person("Java旅途",18, Person.Status.FRER),
            new Person("Java旅途",20, Person.Status.BUSY)
        );
        List<String> collect = personList1.stream()
            .map(Person::getName)
            .collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

## Optional常用方法 ##

Optional类是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。

1.  Optional.of(T t) ——创建一个Optional实例
2.  Optional.empty()——创建一个空的optional实例
3.  Optional.ofNullable(T t)——若t不为null，创建optional实例，否则创建空实例
4.  isPresent()——判断是否包含值
5.  orElse(T t)——如果调用对象包含值，返回该值，否则返回 t
6.  orElseGet(Supplier s)——如果调用对象包含值，返回该值，否则返回 s 获取的值
7.  map(Function f)——如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
8.  flatMap(Function mapper)——与map类似，要求返回值必须是Optional