java基础（十一）java8新特性（lambda表达式、函数式接口、方法引用、stream、optional）

import org.junit.Test;

import java.util.Comparator;

public class LambdaTest {

    @Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("你好");
            }
        };
        r1.run();

        //lambda表达式
        Runnable r2 = () -> System.out.println("你好");
        r2.run();
    }

    @Test
    public void test2() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare1 = com1.compare(12, 21);
        System.out.println(compare1);
        System.out.println(" ********************");

        //lambda表达式
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        int compare2 = com2.compare(32, 21);
        System.out.println(compare2);
        System.out.println(" ********************");

        //方法引用
        Comparator<Integer> com3 = Integer::compare;
        int compare3 = com3.compare(32, 21);
        System.out.println(compare3);
    }


}

1.2 lambda表达式语法的使用

1.2.1 格式

-> :lambda操作符或箭头操作符.
->左边: Lambda形参列表 (其实就是接口中的抽象方法的形参列表)
->右边: Lambda体 (其实就是重写的抽象方法的方法体)

1.2.2 Lambda表达式的使用: 无参数，无返回值

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {

    //语法形式一：无参数，无返回值
    @Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("***********************");
        Runnable r2 = () -> System.out.println("我爱北京故宫");
        r2.run();
    }

}

1.2.3 Lambda表达式的使用: Lambda 需要一个参数，但是没有返回值。

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {


    //语法格式二: Lambda 需要一个参数，但是没有返回值。
    @Test
    public void test2() {
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别是什么? ");

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

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听得人当真了，一个是说的人当真了");
    }


}

1.2.4 Lambda表达式的使用: 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {


    //语法格式三:数据类型可以省略，因为可由编译器推断得出，称为“类型推断
    @Test
    public void test3() {
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听得人当真了，一个是说的人当真了");
        System.out.println("******************");
        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("一个是听得人当真了，一个是说的人当真了");

        /*
         * 类型推断的其他例子
         * ArrayList<String> list = new ArrayList<>();//类型推断
         * int[] arr = {1,2,3};//类型推断
         * */
    }


}

1.2.5 Lambda表达式的使用: Lambda 若只需要一个参数时，参数的小括号可以省略

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {


    //语法格式四: Lambda 若只需要一个参数时， 参数的小括号可以省略
    @Test
    public void test4() {
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听得人当真了，一个是说的人当真了");
        System.out.println(" *******************");
        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("一个是听得人当真了，一个是说的人当真了");
    }

}

1.2.6 Lambda表达式的使用: Lambda 需要两个或以上的参数，多条执行语句，开且可以有返回值

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {

    //语法格式五: Lambda 需要两个或以上的参数，多条执行语句，开且可以有返回值
    @Test
    public void test5() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(12, 21));
        System.out.println("***************************");

        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(12, 21));
    }

}

1.2.7 Lambda表达式的使用:当Lambda体只有一条语句时，return. 与大括号若有，都可以省略

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {

    //语法格式六:当Lambda体只有一条语句时，return. 与大括号若有， 都可以省略
    @Test
    public void test7() {
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12, 6));
        System.out.println("*************************");
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12, 21));
    }

}

二、函数式接口

2.1 基本概念

只包含一个抽象方法的接口，称为函数式接口。

你可以通过 Lambda表达式来创建该接口的对象。( 若Lambda表达式抛出一个受检异常(即:非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明)。

我们可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

在java.util.function包下定义了Java 8的丰富的函数式接口

2.2 如何理解函数式接口

java不但可以支持OOP还可以支持OOF(面向函数编程)

在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型一函数式接口。

简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。

以前用匿名实现类表示的现在都可以用L ambda表达式来写。

2.3 java内置四大核心函数式接口

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class LambdaTest2 {

    @Test
    public void test1() {
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double adouble) {
                System.out.println("去买了瓶矿泉水，价格为:" + adouble);
            }
        });

        happyTime(400,
                consumer -> System.out.println("去买了瓶矿泉水，价格为:" + consumer));
    }

    public void happyTime(double money, Consumer<Double> con) {
        con.accept(money);
    }

    @Test
    public void test2() {
        List<String> list = Arrays.asList("北京", "南京", "天津", 
                            "东京", "西京", "普京");
        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(filterStrs);

        List<String> filterStrs1 = filterString(list, s -> s.contains("京"));
        System.out.println(filterStrs1);
    }

    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre) {
        ArrayList<String> filterList = new ArrayList<>();
        for (String s : list) {
            if (pre.test(s)) {
                filterList.add(s);
            }
        }
        return filterList;
    }
}

三、方法引用与构造器引用

3.1 方法引用基本概念

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用。

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

要求: 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致

格式: 使用操作符“::”将类(或对象)与方法名分隔开来。

如下三种主要使用情况:

➢对象::实例方法名
➢类::静态方法名
➢类::实例方法名

3.2 方法引用使用示例

3.2.1 对象::实例方法

consumer中的 void accept(T t)
PrintStrean中的 void printin(T t)

    @Test
    public void test3() {
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("*****************");
        
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("beijing");
    }

    @Test
    public void test2() {
        Employee emp = new Emp1oyee(1001, "Tom", 23, 5600);
        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());
        System.out.println("****************");

        Supplier<String> sup2 = emp::getName;
        System.out.println(sup2.get());
    }

3.2.2 类::静态方法

Comparator中的 int compare(T t1,T t2)
Integer中的 int compare(T t1,T t2)

    @Test
    public void test4() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 21));
        System.out.println("******************");
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 3));
    }

3.2.3 类::实例方法

Comparator中的 int comapre(T t1,T t2)
String中的 int t1. compareTo(t2)

    @Test
    public void test5() {
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));
        System.out.println("*****************");
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abd", "abm"));
    }

3.3 构造器引用

    @Test
    public void test1() {
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("************************");
        Supplier<Employee> sup1 = () -> new Employee();
        System.out.println(sup1.get());
        System.out.println("************************");
        Supplier<Employee> sup2 = Employee::new;
        System.out.println(sup2.get());
    }

四、stream API

4.1 简单介绍

Java8中有两大最为重要的改变。第一个是Lambda表达式; 另外一个则是Stream API。

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

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

4.1.1 为什么使用stream api

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

java8中的stream与InputStream和OutputStream是完全不同的概念，stream是用于对集合迭代器

的增强，使之完成能够完成更高效的聚合操作(过滤、排序、统计分组）或者大批量数据操作。

此外与stream与lambada表达示结合后编码效率与大大提高，且可读性更强。

代码示例：

public class AppleServer {

    private static List<Apple> appleStore = new ArrayList<>();

    static {
        appleStore.add(new Apple("red", 1));
        appleStore.add(new Apple("red", 2));
        appleStore.add(new Apple("green", 3));
        appleStore.add(new Apple("yellow", 4));
        appleStore.add(new Apple("red", 5));
    }

    public void test1() {
        for (Apple apple : appleStore) {
            if (apple.getColor().equals("red")) {
                //add
            }
        }
    }

    public void test2() {
        List<Apple> list = appleStore.stream()
                .filter(a -> a.getColor().equals("red"))
                .collect(Collectors.toList());
    }

    @Test
    public void test3() {
        //计算每种颜色苹果的个数以及平均重量
        appleStore.stream()
                .collect(Collectors.groupingBy(a -> a.getColor(),
                        Collectors.averagingInt(a -> a.getWeight())))
                .forEach((k, v) -> System.out.println(k + ":" + v));
    }
}

@AllArgsConstructor
@Data
class Apple {
    private String color;
    private int weight;
}

4.1.2 Stream和Collection集合的区别:

Collection 是一种静态的内存数据结构，主要面向内存，存储在内存中
Stream是有关计算的，主要是面向CPU，通过CPU实现计算。

4.1.3 什么是stream

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

注意:

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

4.1.4 stream的操作三个步骤

1 创建Stream

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

2 中间操作

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

3 终止操作(终端操作)

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

4.2 并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

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

4.3 Stream实例化

4.3.1 创建Stream方式一: 通过集合

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

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

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {

    public String name;
    public Integer age;

    public static List<Employee> getEmployee() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("name", 5));
        return list;
    }
}

public class StreamAPITest {

    @Test
    public void test1() {
        List<Employee> employees = Employee.getEmployee();

        //default Stream<E> stream() :返回一个顺序流.顺序流按照顺序获取数据
        Stream<Employee> stream = employees.stream();

        //default Stream<E> parallelStream():返回一个并行流，并不一定按照顺序获取数据
        Stream<Employee> parallelStream = employees.parallelStream();
    }
}

4.3.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)

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {

    public String name;
    public Integer age;

    public static List<Employee> getEmployee() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("name", 5));
        return list;
    }
}


public class StreamAPITest {

    @Test
    public void test2() {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};

        //调用Arrays,类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);
        Employee e1 = new Employee("Tom", 2);
        Employee e2 = new Employee("Jerry", 3);
        Employee[] arr1 = new Employee[]{e1, e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }

}

4.3.3 创建Stream方式三，通过Stream的of()

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

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

    @Test
    public void test3() {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }

4.4 stream的中间操作——惰性求值

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

4.4.1 筛选与切片

练习：查询员工年龄大于35岁的员工

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {

    public String name;
    public Integer age;

    public static List<Employee> getEmployee() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("JIRA", 45));
        return list;
    }


public class StreamAPITest {

    @Test
    public void test1() {
        List<Employee> employees = Employee.getEmployee();

        //       default Stream<E> stream() :返回一个顺序流
        Stream<Employee> stream = employees.stream();
        //filter 接收Lambda ，从流中排除某些元素。
        stream.filter(e -> e.getAge() > 35).forEach(System.out::println);
        System.out.println("----------------------------------------------");

        //limit  截断流，使其元素不超过给定数量。
        employees.stream().limit(1).forEach(System.out::println);
        System.out.println("----------------------------------------------");

        //skip  跳过元素，返回一个扔掉了前n个元素的流
        employees.stream().skip(5).forEach(System.out::println);
        System.out.println("----------------------------------------------");

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

4.4.2 映射——美团面试问过

map类似于list的add方法；flatMap类似于list里的addAll方法

代码示例

public class StreamAPITest {

    @Test
    public void test2() {
        //map(Function f) - 接收一个函数作为参数，将元素转换成其他形式或提取信息
        List<String> list = Arrays.asList("aa", "bb");
        list.stream().map(String::toUpperCase).forEach(System.out::println);
        System.out.println("---------------------------------------------");

        Stream<Stream<Character>> streamStream = list.stream().
                            map(StreamAPITest::fromStringToStream);
        streamStream.forEach(
                s -> {
                    s.forEach(System.out::println);
                }
        );
        System.out.println("---------------------------------------------");

        // fLatMap(Function f)- 接收一 个函数作为参数，将流中的每个值都换成另一个流
        Stream<Character> characterStream = list.stream().
                            flatMap(StreamAPITest::fromStringToStream);
        characterStream.forEach(System.out::println);
        System.out.println("---------------------------------------------");
    }

    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str) {
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

}

4.4.3 排序

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {

    public String name;
    public Integer age;

    public static List<Employee> getEmployee() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("JIRA", 45));
        return list;
    }
}

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

    List<Employee> employee = Employee.getEmployee();
    employee.stream().sorted(
             (e1, e2) -> Integer.compare(e1.getAge(), e2.getAge())).
             forEach(System.out::println);
}

4.5 stream的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如: List、 Integer, 甚至是void。

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

4.5.1 匹配与查找

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {

    public String name;
    public Integer age;

    public static List<Employee> getEmployee() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("TOM", 5));
        list.add(new Employee("JIRA", 45));
        return list;
    }
}

public class StreamAPITest {

    //1-匹配与查找
    @Test
    public void test3() {
        List<Employee> employees = Employee.getEmployee();

        //  allMatch(Predicate p)一检查是否匹配所有元素。
        //  练习:是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);
        System.out.println("-------------------------------------");

        //   anyMatch(Predicate p)一检查是 否至少匹配-一个元素。
        //   练习:是否存在员工的工资大于10000
        System.out.println(employees.stream().anyMatch(e -> e.getAge() > 10000));
        System.out.println("-------------------------------------");

        // noneMatch(Predicate p)-检查是否没有匹配的元素。
        // 练习:是否存在员工姓雷
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().
                            startsWith("雷"));
        System.out.println(noneMatch);
        System.out.println("-------------------------------------");

        // findFirst-返回第一个元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println(employee);
        System.out.println("-------------------------------------");

        //  findAny-返回当前流 中的任意元素
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1);
        System.out.println("-------------------------------------");

        //count-返回流 中元素的总个数
        long count = employees.stream().filter(e -> e.getAge() > 5000).count();
        System.out.println(count);
        System.out.println("-------------------------------------");

        //   max(Comparator c)一返回流中最大值
        // 练习:返回最高的工资:
        Stream<Integer> ageStream = employees.stream().map(Employee::getAge);
        Optional<Integer> maxAge = ageStream.max(Integer::compare);
        System.out.println(maxAge);
        System.out.println("-------------------------------------");
    }
}

4.5.2 归约

备注:

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

    @Test
    public void test5() {
        //reduce( T identity, BinaryOperator
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(list.stream().reduce(0, Integer::sum));

        //reduce(BinaryOperator)一可以将流中元素反复结合起来， 得到一个值。返回Optiond
        // 练习2:计算公司所有员工年龄的总和
        List<Employee> employees = Employee.getEmployee();
        Stream<Integer> ageStream = employees.stream().map(Employee::getAge);
        Optional<Integer> sumMoney = ageStream.reduce(Integer::sum);
        //or Optional<Integer> sumMoney = ageStream.reduce((age1, age2)->age1+age2);
        System.out.println(sumMoney);
    }

4.5.3 收集

Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到List、Set、Map)。

另外，Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表:

五、optional类——最大化减少空指针异常

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

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

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

5.1 optional类的api

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

5.1.1 创建Optional类对象的方法

➢Optional.of(T t): 创建一个Optional实例，t必须非空;
➢Optional.empty() : 创建一个空的Optional实例
➢Optional.ofNullable(T t): 坷以为null

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

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

5.1.3 获取Optional容器的对象

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