010-jdk1.8版本新特性二-Optional类,Stream流

Posted bjlhx

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了010-jdk1.8版本新特性二-Optional类,Stream流相关的知识,希望对你有一定的参考价值。

1.5、Optional类

1、定义

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

Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

2、声明

以下是一个 java.util.Optional<T> 类的声明:

public final class Optional<T> extends Object

3、类方法

技术分享图片
序号    方法 & 描述
1    static <T> Optional<T> empty()
返回空的 Optional 实例。

2    boolean equals(Object obj)
判断其他对象是否等于 Optional。

3    Optional<T> filter(Predicate<? super <T> predicate)
如果值存在,并且这个值匹配给定的 predicate,返回一个Optional用以描述这个值,否则返回一个空的Optional。

4    <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)
如果值存在,返回基于Optional包含的映射方法的值,否则返回一个空的Optional

5    T get()
如果在这个Optional中包含这个值,返回值,否则抛出异常:NoSuchElementException

6    int hashCode()
返回存在值的哈希码,如果值不存在 返回 07    void ifPresent(Consumer<? super T> consumer)
如果值存在则使用该值调用 consumer , 否则不做任何事情。

8    boolean isPresent()
如果值存在则方法会返回true,否则返回 false9    <U>Optional<U> map(Function<? super T,? extends U> mapper)
如果存在该值,提供的映射方法,如果返回非null,返回一个Optional描述结果。

10    static <T> Optional<T> of(T value)
返回一个指定非null值的Optional。

11    static <T> Optional<T> ofNullable(T value)
如果为非空,返回 Optional 描述的指定值,否则返回空的 Optional。

12    T orElse(T other)
如果存在该值,返回值, 否则返回 other。

13    T orElseGet(Supplier<? extends T> other)
如果存在该值,返回值, 否则触发 other,并返回 other 调用的结果。

14    <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)
 

如果存在该值,返回包含的值,否则抛出由 Supplier 继承的异常

15    String toString()
返回一个Optional的非空字符串,用来调试
View Code

注意: 这些方法是从 java.lang.Object 类继承来的。

4、示例

import java.util.Optional;
 
public class Java8Tester {
   public static void main(String args[]){
   
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
        
      // Optional.ofNullable - 允许传递为 null 参数
      Optional<Integer> a = Optional.ofNullable(value1);
        
      // Optional.of - 如果传递的参数是 null,抛出异常 NullPointerException
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
    
   public Integer sum(Optional<Integer> a, Optional<Integer> b){
    
      // Optional.isPresent - 判断值是否存在
        
      System.out.println("第一个参数值存在: " + a.isPresent());
      System.out.println("第二个参数值存在: " + b.isPresent());
        
      // Optional.orElse - 如果值存在,返回它,否则返回默认值
      Integer value1 = a.orElse(new Integer(0));
        
      //Optional.get - 获取值,值需要存在
      Integer value2 = b.get();
      return value1 + value2;
   }
}

输出

第一个参数值存在: false
第二个参数值存在: true
10

1.6、Stream流

1、定义

Stream(流)是一个来自数据源的元素队列并支持聚合操作

  • <strong元素队列< strong="">元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
  • 数据源 流的来源。 可以是集合,数组,I/O channel, 产生器generator 等。
  • 聚合操作 类似SQL语句一样的操作, 比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同, Stream操作还有两个基础的特征:

  • Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
  • 内部迭代: 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。

由于操作过程完全由Java处理,因此它可以根据当前硬件环境选择最优的方法处理,我们也无需编写复杂又容易出错的多线程代码了。

2、生成流

在 Java 8 中, 集合接口有两个方法来生成流:

  • stream() − 为集合创建串行流。

  • parallelStream() − 为集合创建并行流。

3、流的操作种类

流的操作分为两种,分别为中间操作 和 终端操作。
中间操作
  当数据源中的数据上了流水线后,这个过程对数据进行的所有操作都称为“中间操作”。
  中间操作仍然会返回一个流对象,因此多个中间操作可以串连起来形成一个流水线。
  中间操作都是filter()、distinct()、sorted()、map()、flatMap()等,其一般是对数据集的整理(过滤、排序、匹配、抽取等)
终端操作
  当所有的中间操作完成后,若要将数据从流水线上拿下来,则需要执行终端操作。
  终端操作将返回一个执行结果,这就是你想要的数据。
  终止方法往往是完成对数据集中数据的处理,如forEach(),还有allMatch()、anyMatch()、findAny()、 findFirst(),数值计算类的方法有sum、max、min、average等等。终止方法也可以是对集合的处理,如reduce()、 collect()等等。reduce()方法的处理方式一般是每次都产生新的数据集,而collect()方法是在原数据集的基础上进行更新,过程中不产生新的数据集。

4、流的操作过程

使用流一共需要三步:
准备一个数据源

技术分享图片
1、集合 
这种数据源较为常用,通过stream()方法即可获取流对象:
List<Person> list = new ArrayList<Person>(); 
Stream<Person> stream = list.stream();
2、数组 
通过Arrays类提供的静态函数stream()获取数组的流对象:
String[] names = {"chaimm","peter","john"};
Stream<String> stream = Arrays.stream(names);
3.直接将几个值变成流对象:
Stream<String> stream = Stream.of("chaimm","peter","john");
4、文件 
try(Stream lines = Files.lines(Paths.get(“文件路径名”),Charset.defaultCharset())){ 
//可对lines做一些操作 
}catch(IOException e){ 
} 
PS:Java7简化了IO操作,把打开IO操作放在try后的括号中即可省略关闭IO的代码。
View Code

执行中间操作 【中间操作可以有多个,它们可以串连起来形成流水线。】、执行终端操作 【执行终端操作后本次流结束,你将获得一个执行结果。】

5、流转换为其他数据结构

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection【list,set,stack】
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

6、使用

6.1、筛选filter

filter函数接收一个Lambda表达式作为参数,该表达式返回boolean,在执行过程中,流将元素逐一输送给filter,并筛选出执行结果为true的元素。

List<Person> result = list.stream()
                    .filter(p->p.getIsStudent())
                    .collect(toList());

6.2、去重distinct

返回一个有唯一元素的stream(根据stream中元素的equals实现)。内部需要重写equals

List<Person> result = list.stream()
                    .distinct()
                    .collect(toList());

6.3、截取limit

截取流的前N个元素:

List<Person> result = list.stream()
                    .limit(3)
                    .collect(toList());

6.4、跳过【skip】

跳过流的前n个

List<Person> result = list.stream()
                    .skip(3)
                    .collect(toList());

6.5、映射【map】

对流中的每个元素执行一个函数,使得元素转换成另一种类型输出。流会将每一个元素输送给map函数,并执行map中的Lambda表达式,最后将执行结果存入一个新的流中。 

final List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
final List<Integer> doubleNumbers = numbers.stream().map(number -> number * 2).collect(Collectors.toList());
System.out.println(doubleNumbers);

6.6、合并【flagmap】

List<String> list = new ArrayList<String>();
list.add("I am a boy");
list.add("I love the girl");
list.add("But the girl loves another girl");
list.stream()
            .map(line->line.split(" "))
            .flagmap(Arrays::stream)
            .distinct()
            .collect(toList());

6.7、排序【sorted】

不指定一个自定义的Comparator则会使用默认排序。

        result = list.stream()
                .sorted((a,b)->a.getAge().compareTo(b.getAge()))
                .collect(toList());

        result = list.stream()
                .sorted(Comparator.comparing(Person::getAge))
                .collect(toList());

6.8、是否匹配任意一个元素anyMatch

anyMatch用于判断流中是否存在至少一个元素满足指定的条件,这个判断条件通过Lambda表达式传递给anyMatch,执行结果为boolean类型。 

//如,判断list中是否有学生:
boolean result = list.stream().anyMatch(Person::isStudent);
//等价于
boolean result = list.stream().anyMatch(p->p.getIsStudent());

6.9、是否匹配所有元素:allMatch

allMatch用于判断流中的所有元素是否都满足指定条件,这个判断条件通过Lambda表达式传递给anyMatch,执行结果为boolean类型。

如,判断是否所有人都是学生:
boolean result = list.stream().allMatch(Person::isStudent);

6.10、是否未匹配所有元素:noneMatch

noneMatch与allMatch恰恰相反,它用于判断流中的所有元素是否都不满足指定条件:

boolean result = list.stream().noneMatch(Person::isStudent);

6.11、获取任一元素findAny

findAny能够从流中随便选一个元素出来,它返回一个Optional类型的元素。

Optional<Person> person = list.stream().findAny();

6.12、获取第一个元素

Optional<Person> person = list.stream().findFirst();

7、聚合操作-Stream.reduce

  Stream.reduce,常用的方法有average, sum, min, max, and count,返回单个的结果值,并且reduce操作每处理一个元素总是创建一个新值

  归约是将集合中的所有元素经过指定运算,折叠成一个元素输出,如:求最值、平均数等,这些操作都是将一个集合的元素折叠成一个元素输出。
  在流中,reduce函数能实现归约。

T reduce(T identity, BinaryOperatoraccumulator)
// identity:它允许用户提供一个循环计算的初始值。accumulator:计算的累加器,其方法签名为apply(T t,U u),在该reduce方法中第一个参数t为上次函数计算的返回值,
// 第二个参数u为Stream中的元素,这个函数把这两个值计算apply,得到的和会被赋值给下次执行这个方法的第一个参数。有点绕看代码:
int value = Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item); Assert.assertSame(value, 110); /* 或者使用方法引用 */ value = Stream.of(1, 2, 3, 4).reduce(100, Integer::sum); //这个例子中100即为计算初始值,每次相加计算值都会传递到下一次计算的第一个参数。

reduce还有其它两个重载方法:
Optionalreduce(BinaryOperatoraccumulator):与上面定义基本一样,无计算初始值,所以他返回的是一个Optional。
U reduce(U identity, BiFunction accumulator, BinaryOperator combiner):与前面两个参数的reduce方法几乎一致,你只要注意到BinaryOperator其实实现了BiFunction和BinaryOperator两个接口。
Integer类还提供了min、max等一系列数值操作,当流中元素为数值类型时可以直接使用。

8、 聚合操作-Stream.collect

  收集器用来将经过筛选、映射的流进行最后的整理,可以使得最后的结果以不同的形式展现。
  流由一个个元素组成,归约就是将一个个元素“折叠”成一个值,如求和、求最值、求平均值都是归约操作。

Collectors
  toList()、toSet、joining、mapping、sum、age、group、max、min

8.1、count

        long count = list.stream().count();
        Long count2 = list.stream().collect(Collectors.counting());

8.2、max,min

        Optional<Person> personOptionalMax = list.stream().max(Comparator.comparing(p -> p.getAge()));
        Optional<Person> personOptionalMax1 = list.stream().collect(maxBy(Comparator.comparing(Person::getAge)));


        Optional<Person> personOptionalMin = list.stream().min(Comparator.comparing(p -> p.getAge()));
        Optional<Person> personOptionalMin1 = list.stream().collect(minBy(Comparator.comparing(Person::getAge)));

8.3、sum、avg

        Integer sum = list.stream().collect(summingInt(Person::getAge));
        Double avg = list.stream().collect(averagingInt(Person::getAge));

8.4、summarizingInt一次性计算所有归约操作

Collectors.summarizingInt函数能一次性将最值、均值、总和、元素个数全部计算出来,并存储在对象IntSummaryStatisics中。
可以通过该对象的getXXX()函数获取这些值。

        DoubleSummaryStatistics dss = list.stream().collect(Collectors.summarizingDouble(p->p.getAge()));
        double average=dss.getAverage();
        double max=dss.getMax();
        double min=dss.getMin();
        double sum1=dss.getSum();
        double count1=dss.getCount();

8.5、Join

String names = list.stream().collect(Collectors.joining());
//每个字符串默认分隔符为空格,若需要指定分隔符,则在joining中加入参数即可:
String names = list.stream().collect(Collectors.joining(", "));

8.6、自定义规约

若你需要自定义一个归约操作,那么需要使用Collectors.reducing函数,该函数接收三个参数:
第一个参数为归约的初始值
第二个参数为归约操作进行的字段
第三个参数为归约操作的过程

//例:计算所有人的年龄总和
Optional<Integer> sumAge = list.stream().collect(Collectors.reducing(0,Person::getAge,(i,j)->i+j));

Collectors.reducing方法还提供了一个单参数的重载形式。
你只需传一个归约的操作过程给该方法即可(即第三个参数),其他两个参数均使用默认值。
第一个参数默认为流的第一个元素
第二个参数默认为流的元素
这就意味着,当前流的元素类型为数值类型,并且是你要进行归约的对象。

//例:采用单参数的reducing计算所有人的年龄总和
Optional<Integer> sumAge = list.stream().filter(Person::getAge).collect(Collectors.reducing((i,j)->i+j));

8.7、结果收集

Collectors.toList()、Collectors.toMap、Collectors.toSet

注意:其中Collectors.toMap方法的第三个参数为键值重复处理策略,如果不传入第三个参数,当有相同的键时,会抛出一个IlleageStateException。

8.8、分组和分区

对具有相同特性的值进行分组是一个很常见的任务,Collectors提供了一个groupingBy方法,方法签名为:

Collector<T,?,Map> groupingBy(Function classifier, Collector downstream)

classifier:一个获取Stream元素中主键方法。downstream:一个操作对应分组后的结果的方法。这里可进行很多分组后的二次操作,如再次分组,统计等

//示例 根据年龄分组
Map<Integer, List<Person>> collect = list.stream().collect(Collectors.groupingBy(p -> p.getAge(), Collectors.toList()));

多级分组

        //先按照年龄分组,再分组内再次按照名称分组
        Map<Integer, Map<String, List<Person>>> collect1 = list.stream().collect(
                Collectors.groupingBy(p -> p.getAge(), Collectors.groupingBy(t -> t.getName())));

分区是分组的一种特殊情况,它只能分成true、false两组。

  分区使用partitioningBy方法,该方法接收一个Lambda表达式,该表达是必须返回boolean类型,partitioningBy方法会将Lambda返回结果为true和false的元素各分成一组。

  partitioningBy方法返回的结果为Map< Boolean,List< T>>。

  此外,partitioningBy方法和groupingBy方法一样,也可以接收第二个参数,实现二级分区或对分区结果进行统计。

  groupingBy与partitioningBy,它们的区别是partitioningBy为键值为Boolean类型的groupingBy,这种情况下它比groupingBy更有效率。

9、数值流的使用

采用reduce进行数值操作会涉及到基本数值类型和引用数值类型之间的装箱、拆箱操作,因此效率较低。 当流操作为纯数值操作时,使用数值流能获得较高的效率。

1、将普通流转换成数值流
  StreamAPI提供了三种数值流:IntStream、DoubleStream、LongStream,也提供了将普通流转换成数值流的三种方法:mapToInt、mapToDouble、mapToLong。
  如,将Person中的age转换成数值流:

IntStream stream = list.stream().mapToInt(Person::getAge);

2 数值计算

  每种数值流都提供了数值计算函数,如max、min、sum等。
  如,找出最大的年龄:

OptionalInt maxAge = list.stream().mapToInt(Person::getAge).max();

  由于数值流可能为空,并且给空的数值流计算最大值是没有意义的,因此max函数返回OptionalInt,它是Optional的一个子类,能够判断流是否为空,并对流为空的情况作相应的处理。
  此外,mapToInt、mapToDouble、mapToLong进行数值操作后的返回结果分别为:OptionalInt、OptionalDouble、OptionalLong

 

 

以上是关于010-jdk1.8版本新特性二-Optional类,Stream流的主要内容,如果未能解决你的问题,请参考以下文章

Java8新特性Optional类在处理空值判断场景的应用 回避空指针异常 编写健壮的应用程序

乐字节-Java8新特性之Optional

Java8 新特性 Optional 类

JDK8之Optional新特性

Java8新特性 - Optional容器类

Java8新特性--Optional