实例理解Java8新特性中Stream API和Optional类的使用

在学习Java8新特性中Stream API和Optional类的时候，发现学习的时候不系统，用的时候总是忘记怎么去使用。所以总结一些实例，便于理解其使用。

Stream API

Stream简介

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

什么是Stream？

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

注意事项

• Stream 自己不会存储元素。
• Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream的使用

Stream操作的三个步骤

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

图解Stream的操作步骤

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qb9v9dBL-1592729583891)(F:\知识库\Java\Java8新特性\Java8新特性.assets\image-20200620202143071.png)]

创建Stream

1.通过集合创建Stream

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

• default Stream<E> stream() : 返回一个顺序流
• default Stream<E> parallelStream() : 返回一个并行流

2.通过数组创建Stream

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

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

重载形式，能够处理对应基本类型的数组：

• public static IntStream stream(int[] array)
• public static LongStream stream(long[] array)
• public static DoubleStream stream(double[] array)

3.通过Stream的静态方法of()创建Stream

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

• public static<T> Stream<T> of(T... values): 返回一个流

4.创建无限流

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

• 迭代
  public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
• 生成
  public static<T> Stream<T> generate(Supplier<T> s)

示例

@Test
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的中间操作

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

新建一个学生类，方便测试。

public class Student {

    private String name;
    private int age;
    private Gender gender;

    public Student () {
    }

    public Student ( String name, int age, Gender gender ) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName () {
        return name;
    }

    public void setName ( String name ) {
        this.name = name;
    }

    public int getAge () {
        return age;
    }

    public void setAge ( int age ) {
        this.age = age;
    }

    public Gender getGender () {
        return gender;
    }

    public void setGender ( Gender gender ) {
        this.gender = gender;
    }

    @Override
    public boolean equals ( Object o ) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name) &&
                gender == student.gender;
    }

    @Override
    public int hashCode () {
        return Objects.hash(name, age, gender);
    }

    @Override
    public String toString () {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }

    /** 性别枚举 */
    public enum Gender{
        /** 男 */
        MAN,
        /** 女 */
        WOMAN;
    }

}

创建一个集合方便测试

List<Student> studentList = Arrays.asList(
        new Student("李四", 59, Student.Gender.MAN),
        new Student("张三", 18, Student.Gender.MAN),
        new Student("王五", 28, Student.Gender.MAN),
        new Student("赵小苗", 8, Student.Gender.WOMAN),
        new Student("赵小苗", 8, Student.Gender.WOMAN),
        new Student("李芳", 8, Student.Gender.WOMAN)
);

1.筛选与切片

方法	描述
filter(Predicate p)	接收Lambda ，从流中排除某些元素。
distinct()	筛选，通过流所生成元素的hashCode() 和equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量。
skip(long n)	跳过元素，返回一个扔掉了前n 个元素的流。若流中元素不足n 个，则返回一个空流。与limit(n) 互补

使用示例

@Test
public void test2 () {
    System.out.println("---测试filter，过滤信息---");
    Stream<Student> studentStream = studentList.stream()
            .filter(s -> s.getAge() > 20);
    studentStream.forEach(System.out::println);

    System.out.println("---测试limit,取前1个元素---");
    studentList.stream()
            .filter((e) -> e.getAge() >= 20)
            .limit(1)
            .forEach(System.out::println);

    System.out.println("---测试skip，跳过1个元素---");
    studentList.stream()
            .filter((e) -> e.getAge() >= 20)
            .skip(1)
            .forEach(System.out::println);

    System.out.println("---测试distinct，去重---");
    studentList.stream()
            .distinct()
            .forEach(System.out::println);
}

结果：

---测试filter，过滤信息---
Student{name='李四', age=59, gender=MAN}
Student{name='王五', age=28, gender=MAN}
---测试limit,取前1个元素---
Student{name='李四', age=59, gender=MAN}
---测试skip，跳过1个元素---
Student{name='王五', age=28, gender=MAN}
---测试distinct，去重---
Student{name='李四', age=59, gender=MAN}
Student{name='张三', age=18, gender=MAN}
Student{name='王五', age=28, gender=MAN}
Student{name='赵小苗', age=8, gender=WOMAN}

2.映射

方法	描述
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的素。
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

使用示例

public class StreamTest {

    @Test
    public void test3 () {
        Stream<String> stringStream = studentList.stream()
                .map(Student::getName);
        stringStream.forEach(System.out::println);

        //map与flatMap的区别    与list的add、addAll方法区别类似
        List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");

        Stream<String> stream = strList.stream()
                .map(String::toUpperCase);

        stream.forEach(System.out::println);

        Stream<Stream<Character>> stream2 = strList.stream()
                .map(StreamTest::filterCharacter);

        stream2.forEach((sm) -> {
            sm.forEach(System.out::println);
        });

        System.out.println("---------------------------------------------");
        Stream<Character> stream3 = strList.stream()
                .flatMap(StreamTest::filterCharacter);
        
        stream3.forEach(System.out::println);
    }

    private static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();

        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();
    }

}

3.排序

方法	描述
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparatorcomp)	产生一个新流，其中按比较器顺序排序

使用示例

@Test
public void test4 () {
    System.out.println("---自然排序---");
    studentList.stream()
            .map(Student::getName)
            .sorted()
            .forEach(System.out::println);

    System.out.println("---定制排序---");
    studentList.stream()
            .sorted((x,y)->{
                if(x.getAge() == y.getAge()){
                    return x.getName().compareTo(y.getName());
                }else{
                    return Integer.compare(x.getAge(), y.getAge());
                }
            })
            .forEach(System.out::println);

}

结果：

---自然排序---
张三
李四
李芳
王五
赵小苗
赵小苗
---定制排序---
Student{name='李芳', age=8, gender=WOMAN}
Student{name='赵小苗', age=8, gender=WOMAN}
Student{name='赵小苗', age=8, gender=WOMAN}
Student{name='张三', age=18, gender=MAN}
Student{name='王五', age=28, gender=MAN}
Student{name='李四', age=59, gender=MAN}

终止操作

流进行了终止操作后，不能再次使用

1.查找与匹配

方法	描述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicatep)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparatorc)	返回流中最大值
min(Comparatorc)	返回流中最小值
forEach(Consumerc)	内部迭代

注：forEach(Consumerc)，内部迭代(使用Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)。

示例

@Test
public void test5 () {
    boolean b1 = studentList.stream()
            .allMatch(e -> e.getGender().equals(Student.Gender.WOMAN));
    System.out.println("是否有女学生：" + b1);

    Optional<Student> first = studentList.stream()
            .sorted(( x, y ) -> {
                return x.getAge() - y.getAge();
            })
            .findFirst();
    System.out.println("得到年龄最小的学生：\n" + first.get());

    long count = studentList.stream()
            .filter(e->e.getGender().equals(Student.Gender.WOMAN))
            .count();
    System.out.println("女生数量：" + count);
}

结果：

是否有女学生：false
得到年龄最小的学生：
Student{name='赵小苗', age=8, gender=WOMAN}
女生数量：3

2.规约

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

注：map 和reduce 的连接通常称为map-reduce 模式，因Google 用它来进行网络搜索而出名。

@Test
public void test6 () {
    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);

    System.out.println("----------------------------------------");

    Optional<Integer> op = studentList.stream()
            .map(Student::getAge)
            .reduce(Integer::sum);

    System.out.println("所有学生年龄之和" + op.get());
}

结果：

55
----------------------------------------
所有学生年龄之和129

3.收集

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

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。但是Collectors 类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

序号	方法	返回类型	描述
1	toList	List	把流中元素收集到List
2	toSet	Set	把流中元素收集到Set
3	toCollection	Collection	把流中元素收集到创建的集合
4	counting	Long	计算流中元素的个数
5	summingInt	Integer	对流中元素的整数属性求和
6	averagingInt	Double	计算流中元素Integer属性的平均值
7	summarizingInt	IntSummaryStatistics	收集流中Integer属性的统计值。如：平均值
8	joining	String	连接流中每个字符串
9	maxBy	Optional	根据比较器选择最大值
10	minBy	Optional	根据比较器选择最小值
11	reducing	归约产生的类型	从一个作为累加器的初始值开始，利用BinaryOperator与 流中元素逐个结合，从而归约成单个值
12	collectingAndThen	转换函数返回的类型	包裹另一个收集器，对其结果转换函数
13	groupingBy	Map<K,List>	根据某属性值对流分组，属性为K，结果为V
14	partitioningBy	Map<Boolean,List>	根据true或false进行分区

使用示例：

@Test
public void test7 () {
    //测试收集collect
    List<String> list = studentList.stream()
            .map(Student::getName)
            .collect(Collectors.toList());
    System.out.println("学生姓名转集合：" + list);

    Set<String> set = studentList.stream()
            .map(Student::getName)
            .collect(Collectors.toSet());
    System.out.println("学生姓名转Set，去重：" + set);

    //求最小的学生年龄
    Optional<Integer> minAge = studentList.stream()
            .map(Student::getAge)
            .collect(Collectors.minBy(Integer::compare));
    System.out.println("求最小的学生年龄：" + minAge.get());

    System.out.println("---根据性别分组---");
    Map<Student.Gender, List<Student>> map = studentList.stream()
            .collect(Collectors.groupingBy(Student::getGender));
    System.out.println(map);

    System.out.println("---根据年龄和性别多级分组---");
    Map<Student.Gender, Map<String, List<Student>>> map2=studentList.stream()
            .collect(Collectors.groupingBy(Student::getGender,Collectors.groupingBy(e->{
                if(e.getAge() >= 60) {
                    return "老年";
                } else if(e.getAge() >= 35) {
                    return "中年";
                } else {
                    return "成年";
                }
            })));
    System.out.println(map2);

    System.out.println("---根据年龄分区---");
    Map<Boolean, List<Student>> map3 = studentList.stream()
            .collect(Collectors.partitioningBy((e) -> e.getAge() >= 30));
    System.out.println(map3);

    System.out.println("连接流的字符串");
    String str = studentList.stream()
            .map(Student::getName)
            .collect(Collectors.joining("," , "----", "----"));
    System.out.println(str);

    System.out.println("规约收集，求所有学生年龄的和");
    Optional<Integer> sum = studentList.stream()
            .map(Student::getAge)
            .collect(Collectors.reducing(Integer::sum));
    System.out.println(sum.get());
}

结果：

学生姓名转集合：[李四, 张三, 王五, 赵小苗, 赵小苗, 李芳]
学生姓名转Set，去重：[李四, 张三, 赵小苗, 王五, 李芳]
求最小的学生年龄：8
---根据性别分组---
{WOMAN=[Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='李芳', age=8, gender=WOMAN}], MAN=[Student{name='李四', age=59, gender=MAN}, Student{name='张三', age=18, gender=MAN}, Student{name='王五', age=28, gender=MAN}]}
---根据年龄和性别多级分组---
{WOMAN={成年=[Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='李芳', age=8, gender=WOMAN}]}, MAN={成年=[Student{name='张三', age=18, gender=MAN}, Student{name='王五', age=28, gender=MAN}], 中年=[Student{name='李四', age=59, gender=MAN}]}}
---根据年龄分区---
{false=[Student{name='张三', age=18, gender=MAN}, Student{name='王五', age=28, gender=MAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='李芳', age=8, gender=WOMAN}], true=[Student{name='李四', age=59, gender=MAN}]}
连接流的字符串
----李四,张三,王五,赵小苗,赵小苗,李芳----
规约收集，求所有学生年龄的和
129

并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。

了解Fork/Join 框架

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行join 汇总.

图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CyG1g9O9-1592729583902)(F:\知识库\Java\Java8新特性\Java8新特性.assets\image-20200620212853966.png)]

Fork/Join 框架与传统线程池的区别

采用“工作窃取”模式（work-stealing）：

当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务处理方式上。

在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.

而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。

这种方式减少了线程的等待时间,提高了性能。

Optional类

Optional类的由来？解决空指针问题

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。

以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。

受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

Optional类简介

Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null 表示一个值不存在，现在Optional 可以更好的表达这个概念。并且可以避免空指针异常。

Optional类的Javadoc描述如下：

这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional类的使用

创建Optional类对象

• Optional.of(T t): 创建一个Optional 实例，t必须非空
• Optional.empty() : 创建一个空的Optional 实例
• Optional.ofNullable(T t)：若 t 不为 null,创建 Optional 实例,否则创建空实例（t可以为null）

判断Optional容器中是否包含对象

• boolean isPresent() : 判断是否包含对象
• void ifPresent(Consumer<? super T> consumer)：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。

获取Optional容器的对象

• T get(): 如果调用对象包含值，返回该值，否则抛异常
• T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
• T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
• T orElseThrow(Supplier<? extends X> exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

其他

• map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()

• flatMap(Function mapper):与 map 类似，要求返回值必须是Optional

示例

@Test
public void test1 () {
    //测试创建Optional
    Optional<Student> op = Optional.of(new Student( "张三", 18, Student.Gender.MAN));

    Optional<String> s = op.map(Student::getName);
    String name = s.get();
    System.out.println(name);

    Optional<Student> op1 = Optional.ofNullable(null);
    if (op1.isPresent()){
        System.out.println(op1.get());
    }else{
        System.out.println("此对象为空");
    }
    System.out.println(op1.orElse(new Student( "默认", 18, Student.Gender.MAN)));
    
}

结果：

张三
此对象为空
Student{name='默认', age=18, gender=MAN}