欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

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

程序员文章站 2022-06-07 12:35:53
...


在学习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}