java8 新特性 - Stream API

Stream API说明

    java8中有两大最为重要的改变。第一个是lambda表达式；另一个则是Stream API。

    Stream API（java.util.stream）把真正的函数式编程风格引入到java中。这是目前为止对java类库最好的补充，因为Steam API 可以极大的提供java程序员的生产力，让程序员写出更高效、干净、简介的代码

    Stream 是 java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

 

为什么要使用Stream API

    实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongoDB，Redis等，而这些NoSQL的数据就需要java层面去处理。

    Stream和Collection集合的区别：Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。

 

Stream到底是什么呢？

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

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

注意

1. Stream 自己不会存储元素

2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

 

Stream的操作三个步骤

1 . 创建Stream

    一个数据源(如: 集合、数组) ,获取一个流

    （1）通过Collection系列集合提供的stream()方法或者parallelStream()方法来创建Stream。

    （2）通过Arrays中的静态方法stream()获取数组流。

    （3）通过Stream类的静态方法of()获取数组流。

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

    （5）创建空流   Stream<String> empty = Stream.empty();

2.中间操作

   一个中间操作链，对数据源的数据进行处理

  1 - 筛选与切片

   1. filter(Predicate<? super T> predicate)   --接收lambda，从流中排除某些元素。
   2. limit(n) -- 截断流，使其元素不超过给定数量。
   3. skip（n）-- 跳过元素，返回一个人扔掉了前n个元素的流。若流中的元素不足n个，则返回一个空流
   4. distinct() -- 筛选，通过流所生成元素的hashCode()和equals() 去除重复元素
 

   2 - 映射

  1. map(Function f) -- 接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每一元素上，并将其映射成一个新的元素。
   2. flatMat(Function f) -- 接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有流连接成一个流。
 

  3 - 排序

  1. sorted() --自然排序
   2. sorted(Comparator com) -- 定制排序
  

1 - 匹配与查找
  1. boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。
  2. boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。
  3. boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素
  4. Optional<T> findFirst(); -- 返回第一个元素
  5. Optional<T> findAny(); -- 返回当前流中任意一个元素
  6. long count(); -- 返回流中元素的总个数
  7. Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值
  8. Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值
  9. void forEach(Consumer<? super T> action); -- 内部迭代
2 - 规约
  1.T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T
3 - 收集
 <R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法

3.终止操作(终端操作)

   一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

1 - 匹配与查找

   1. boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。
   2. boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。
   3. boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素
   4. Optional<T> findFirst(); -- 返回第一个元素
   5. Optional<T> findAny(); -- 返回当前流中任意一个元素
   6. long count(); -- 返回流中元素的总个数
   7. Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值
   8. Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值
   9. void forEach(Consumer<? super T> action); -- 内部迭代

2 - 规约

   1. T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T
   2. Optional<T> reduce(BinaryOperator<T> accumulator);  -- 可以将流中元素反复结合起来，得到一个值，返回一个 Optional <T>

3 - 收集

  <R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法

 

 

 

 

代码练习

数据准备

package com.sgl.stream;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/*
   <!-- Lombok包 -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.0</version>
      <scope>provided</scope>
    </dependency>
 */

@Data      // get set toString 方法
@AllArgsConstructor   //全参构造方法
@NoArgsConstructor    //空参构造方法
public class Person {
    private int id;
    private String name;
    private  int age;
    private double salary;
}

package com.sgl.stream;

import java.util.ArrayList;
import java.util.List;

/**
 * 提供用于测试的数据
 *
 * @author not_simple
 * @version 1.0
 * @date 2020/5/27 16:31
 */
public class PersonData {

    public static List<Person> getPersons(){
        List<Person> list =new ArrayList<>();

        list.add(new Person(1001,"马化腾",34,1234.33));
        list.add(new Person(1002,"马云",12,9876.66));
        list.add(new Person(1003,"刘强东",33,3210.11));
        list.add(new Person(1004,"雷军",26,7563.12));
        list.add(new Person(1005,"李彦宏",65,5555.65));
        list.add(new Person(1006,"比尔盖茨",42,9501.43));
        list.add(new Person(1007,"任正非",26,4333.32));
        list.add(new Person(1008,"扎克伯格",35,2500.32));
        return list;
    }
}

 

测试Stream的实例化

 

package com.sgl.stream;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 1. Stream 关注的是对数据的运算，与 CPU打交道
 *    集合关注的是数据的存储，与内存打交道
 *
 * 2.
 *  （1）. Stream 自己不会存储元素
 *  （2）. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
 *  （3）. Stream 操作是延时执行的。这意味着他们会等到需要结果的时候才执行
 *
 *  3. Stream 执行流程
 *  （1）. Stream的实例化
 *  （2）. 一系列的中间操作（过滤、映射、...）
 *  （3）. 终止操作
 *
 *  4. 说明：
 *  4.1 一个中间操作链，对数据源的数据进行处理
 *  4.2 一旦执行中翅操作，就回执行中间操作链，并产生结果。之后，不会再被使用
 *
 *
 *
 *
 * @author not_simple
 * @version 1.0
 * @date 2020-6-3 13:28:57
 */

//测试Stream的实例化
public class StreamAPITest {

    //通过Collection系列集合提供的stream()方法或者parallelStream()方法来创建Stream。
    @Test
    public void test1(){
        List<Person> list = PersonData.getPersons();

        /**
         * 流的特性：支持并行流与顺序流
         * 并行流：多个线程同时运行
         * 顺序流：使用主线程，单线程
         */
//      default Stream<E> stream() : 返回一个顺序流
        Stream<Person> stream = list.stream();

//      default Stream<E> parallelStream() : 返回一个并行流
        Stream<Person> parallelStream = list.parallelStream();

    }

    ///创建Stream 方式二: 通过数组
    @Test
    public void test2(){
        int[] arr = new int[] {1,2,3,4,5,6};
//        public static <T> Stream<T> stream(T[] array)
        IntStream stream = Arrays.stream(arr);

        Person person1 = new Person(1001,"sgl",1,123);
        Person person2 = new Person(1002,"sgl11",2,143);
        Person[] arr1 = new Person[]{person1,person2};
        Stream<Person> stream1 = Arrays.stream(arr1);
    }

    //创建Stream 方式二: 通过Stream类的静态方法of()获取数组流。
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }

    //创建Stream方式四： 创建无限流。
    @Test
    public void test4(){
        //迭代
//        public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

        //生成
//        public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

    //创建Stream 方式五：创建空流
    @Test
    public void test5(){
        Stream<String> empty = Stream.empty();
    }
}

 

测试Stream的中间操作

    

package com.sgl.stream;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * 测试Stream的中间操作
 *
 * @author not_simple
 * @version 1.0
 * @date 2020/6/3 14:49
 */
public class StreamAPITest2 {
    //1 - 筛选与切片
    @Test
    public void test1(){
        List<Person> list = PersonData.getPersons();
        //Stream<T> filter(Predicate<? super T> predicate); --接收lambda，从流中排除某些元素。
        Stream<Person> stream = list.stream();
//        练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000 ).forEach(System.out::println);

        System.out.println();
        //limit(n) -- 截断流，使其元素不超过给定数量。

        list.stream().limit(3).forEach(System.out::println);
        System.out.println();

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

        list.stream().skip(3).forEach(System.out::println);
        System.out.println();
        //distinct() -- 筛选，通过流所生成元素的hashCode()和equals() 去除重复元素

        list.add(new Person(1010,"刘庆东",26,33.33));
        list.add(new Person(1010,"刘庆东",26,33.33));
        list.add(new Person(1010,"刘庆东",26,33.33));
        list.add(new Person(1010,"刘庆东",26,33.33));
        list.add(new Person(1010,"刘庆东",26,33.33));
        list.stream().distinct().forEach(System.out::println);
    }

    //2 - 映射
    @Test
    public void test2(){
//        map(Function f) -- 接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每一元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
//        练习1：获取员工姓名长度大于3的员工的姓名
        List<Person> persons = PersonData.getPersons();
        Stream<String> nameStream = persons.stream().map(p -> p.getName());
        nameStream.filter(name -> name.length() > 3 ).forEach(System.out::println);

//        练习2:
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest2::formStringToStream);
        streamStream.forEach(s -> s.forEach(System.out::println));
        System.out.println();

//        flatMat(Function f) -- 接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有流连接成一个流。
//        练习2:
        list.stream().flatMap(StreamAPITest2::formStringToStream).forEach(System.out::println);
    }

//    将一个String 转换成 Stream
    public static Stream<Character> formStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c: str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    //3 - 排序
    @Test
    public void test4(){
//        sorted() --自然排序
        List<Integer> list = Arrays.asList(12, 33, 65, 87, 43, 0, -93, 4);
        list.stream().sorted().forEach(System.out::println);
        System.out.println();

        /*
            java.lang.ClassCastException: com.sgl.stream.Person cannot be cast to java.lang.Comparable
            抛出异常原因 com.sgl.stream.Person 没有实现Comparable接口
         */
//        List<Person> persons = PersonData.getPersons();
//        persons.stream().sorted().forEach(System.out::println);


        //sorted(Comparator com) -- 定制排序
        List<Person> persons = PersonData.getPersons();
        persons.stream().sorted( (e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary())).forEach(System.out::println);
    }

}

 

测试Stream的终止操作

 

package com.sgl.stream;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 测试Stream的终止操作
 *
 *  1 - 匹配与查找
 *    1. boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。
 *    2. boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。
 *    3. boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素
 *    4. Optional<T> findFirst(); -- 返回第一个元素
 *    5. Optional<T> findAny(); -- 返回当前流中任意一个元素
 *    6. long count(); -- 返回流中元素的总个数
 *    7. Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值
 *    8. Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值
 *    9. void forEach(Consumer<? super T> action); -- 内部迭代
 *
 *  2 - 规约
 *    1. T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T
 *    2. Optional<T> reduce(BinaryOperator<T> accumulator);  -- 可以将流中元素反复结合起来，得到一个值，返回一个 Optional <T>
 *  3 - 收集
 *   <R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
 *
 * @author not_simple
 * @version 1.0
 * @date 2020/6/3 16:27
 */
public class StreamAPITest3 {

    // 1 - 匹配与查找
    @Test
    public void test1(){
        List<Person> persons = PersonData.getPersons();

//        boolean allMatch(Predicate<? super T> predicate); -- 检查是否匹配所有元素。
//        练习：是否所有员工的年龄都大于18
        boolean b = persons.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(b);

//      boolean anyMatch(Predicate<? super T> predicate); -- 检查是否至少匹配一个元素。
//        练习：是否存在员工的工资大于 10000
        boolean anyMatch = persons.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

//      boolean noneMatch(Predicate<? super T> predicate); -- 检查是否从没有匹配的元素
//        练习：是否存在员工姓 “雷”
        boolean noneMatch = persons.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);

//        Optional<T> findFirst(); -- 返回第一个元素
        Optional<Person> first = persons.stream().findFirst();
        System.out.println(first);

//        Optional<T> findAny(); -- 返回当前流中任意一个元素
        Optional<Person> any = persons.stream().findAny();
        System.out.println(any);
        //并行流
        Optional<Person> parPerson = persons.parallelStream().findAny();
        System.out.println(parPerson);
    }

    @Test
    public void test2(){
        List<Person> persons = PersonData.getPersons();
//        long count(); -- 返回流中元素的总个数
        long count = persons.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
        System.out.println();

//        Optional<T> max(Comparator<? super T> comparator); -- 返回流中最大值
//        练习:返回最高的工资：
        Stream<Double> maxSalary = persons.stream().map(e -> e.getSalary());
        Optional<Double> max = maxSalary.max(Double::compareTo);
        System.out.println(max);

//        Optional<T> min(Comparator<? super T> comparator); -- 返回流中的最小值
//        练习：返回最低工资的员工
        Optional<Person> min = persons.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);

//        void forEach(Consumer<? super T> action); -- 内部迭代
        persons.stream().forEach(System.out::println);
    }


    //2 - 规约
    @Test
    public void test3(){

//        T reduce(T identity, BinaryOperator<T> accumulator); -- 可以将流中元素反复结合起来，得到一个值，返回一个 T
//      练习1：计算 1 - 10 的自然数的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer reduce = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce);

//        Optional<T> reduce(BinaryOperator<T> accumulator);  -- 可以将流中元素反复结合起来，得到一个值，返回一个 Optional <T>
//        练习2: 计算公司所有员工工资的总和
        List<Person> persons = PersonData.getPersons();
        Stream<Double> doubleStream = persons.stream().map(e -> e.getSalary());
//        Optional<Double> reduce1 = doubleStream.reduce(Double::sum);
        Optional<Double> reduce1 = doubleStream.reduce((d1, d2) -> d1 + d2);
        System.out.println(reduce1);
    }


    //3 - 收集
    @Test
    public void test4(){
//    <R, A> R collect(Collector<? super T, A, R> collector); -- 将流转换为其他形式，接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
        //练习1：查找工资大于6000的员工
        List<Person> persons = PersonData.getPersons();
        List<Person> list = persons.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        list.forEach(System.out::println);
        System.out.println();

        Set<Person> set = persons.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        set.forEach(System.out::println);
        System.out.println();

        Collection<Person> collect = persons.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toCollection(ArrayList::new));
        collect.forEach(System.out::println);
    }
}