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()
返回存在值的哈希码，如果值不存在 返回 0。
 
7    void ifPresent(Consumer<? super T> consumer)
如果值存在则使用该值调用 consumer , 否则不做任何事情。
 
8    boolean isPresent()
如果值存在则方法会返回true，否则返回 false。
 
9    <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的非空字符串，用来调试

注意： 这些方法是从 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的代码。

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

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