1. optional

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。
1.1类方法

  2. package java.util;
  4. import java.util.function.Consumer;
  5. import java.util.function.Function;
  6. import java.util.function.Predicate;
  7. import java.util.function.Supplier;
  9. /**
  10.  * 
  11.  */
  12. public final class Optional<T> {
  13.   //返回描述指定值的可选值，如果为非null，则返回空可选值。
  14.     public static <T> Optional<T> ofNullable(T value) {
  15.         return value == null ? empty() : of(value);
  16.     }
  18.    //如果此选项中存在一个值，则返回该值，否则抛出NoTouchElementException
  19.     public T get() {
  20.         if (value == null) {
  21.             throw new NoSuchElementException("No value present");
  22.         }
  23.         return value;
  24.     }
  26.     //如果存在值，则返回true，否则返回false
  28.     public boolean isPresent() {
  29.         return value != null;
  30.     }
  32.  //如果存在值，则使用该值调用指定的使用者，否则不执行任何操作
  33.     public void ifPresent(Consumer<? super T> consumer) {
  34.         if (value != null)
  35.             consumer.accept(value);
  36.     }
  38.    //如果存在一个值，并且该值与给定谓词匹配，则返回一个描述该值的可选值，否则返回一个空的可选值。
  39.     public Optional<T> filter(Predicate<? super T> predicate) {
  40.         Objects.requireNonNull(predicate);
  41.         if (!isPresent())
  42.             return this;
  43.         else
  44.             return predicate.test(value) ? this : empty();
  45.     }
  47.   //如果存在值，则对其应用提供的映射函数，如果结果为非null，则返回描述结果的可选值。否则，返回一个空的可选值。
  48.     public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
  49.         Objects.requireNonNull(mapper);
  50.         if (!isPresent())
  51.             return empty();
  52.         else {
  53.             return Optional.ofNullable(mapper.apply(value));
  54.         }
  55.     }
  57. //如果存在值，则对其应用提供的可选方向角映射函数，返回该结果，否则返回空的可选值。此方法类似于map（Function），
  58.     //但提供的映射器的结果已经是可选的，如果调用，flatMap不会用额外的可选值包装它。
  59.     public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
  60.         Objects.requireNonNull(mapper);
  61.         if (!isPresent())
  62.             return empty();
  63.         else {
  64.             return Objects.requireNonNull(mapper.apply(value));
  65.         }
  66.     }
  68.   //返回值（如果存在），否则返回其他值。
  69.     public T orElse(T other) {
  70.         return value != null ? value : other;
  71.     }
  73.  //返回值（如果存在），否则调用other并返回该调用的结果。
  74.     public T orElseGet(Supplier<? extends T> other) {
  75.         return value != null ? value : other.get();
  76.     }
  78.   //返回包含的值（如果存在），否则抛出由提供的供应商创建的异常。
  79.     public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
  80.         if (value != null) {
  81.             return value;
  82.         } else {
  83.             throw exceptionSupplier.get();
  84.         }
  85.     }
  86. }

1.2 Optional 类常用方法

  1. public class OptionalTest {
  2.     public static void main(String args[]) {
  3.         OptionalTest optionalTest =new OptionalTest();
  4.         Integer value1 =null;
  5.         Integer value2 =new Integer(5);
  6.         // Optional.ofNullable - 允许传递为 null 参数
  7.         Optional<Integer> a = Optional.ofNullable(value1);
  8.         // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
  9.         Optional<Integer> b = Optional.of(value2);
  10.         System.out.println(optionalTest.sum(a, b));
  11.     }
  13.     public Integer sum(Optional<Integer> a, Optional<Integer> b) {
  14.         // Optional.isPresent - 判断值是否存在
  15.         System.out.println("a: " + a.isPresent());
  16.         System.out.println("b: " + b.isPresent());
  17.         // Optional.orElse - 如果值存在，返回它，否则返回默认值
  18.         Integer value1 = a.orElse(new Integer(0));
  19.         //Optional.get - 获取值，值需要存在
  20.         Integer value2 = b.get();
  21.         return value1 + value2;
  22.     }
  23. }

输出：

  1. a: false
  2. b: true
  3. 5

2.日期时间 API

Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。
在旧版的Java 中，日期时间API 存在诸多问题，其中有：
· 非线程安全 − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。
· 设计很差 − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
· 时区处理麻烦 − 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。
Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：
· Local(本地) − 简化了日期时间的处理，没有时区的问题。
· Zoned(时区) − 通过制定的时区处理日期时间。
新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。
8.1 本地化日期时间 API
LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况。代码如下：

  1. public class LocalDateTest {
  2.     public static void main(String[] args) {
  3.         new LocalDateTest().localDate();
  4.     }
  6.     public void localDate() {
  7.         LocalDateTime currentTime = LocalDateTime.now();
  8.         System.out.println("当前时间: " + currentTime);
  9.         LocalDate currentDate = LocalDate.now();
  10.         System.out.println("当前日期：" + currentDate);
  11.         //将LocalDateTime转为String
  12.         String dateTime =currentTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
  13.         System.out.println(dateTime);
  14.         //将LocalDate转为String
  15.         String date =currentDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
  16.         System.out.println(date);
  17.     }
  18. }

输出：

  1. 当前时间: 2021-08-02T19:22:17.553
  2. 当前日期：2021-08-02
  3. 2021-08-02 19:22:17
  4. 2021-08-02

3. Lambda 表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用Lambda 表达式可以使代码变的更加简洁紧凑。
3.1 语法
lambda 表达式的语法格式如下：
(parameters) -> expression或(parameters) ->{statements; }
以下是lambda表达式的重要特征:
· 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
· 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
· 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
· 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
Lambda 表达式实例

  1. public class LambdaTest {
  2.     public static void main(String[] args) {
  3.         LambdaTest lt = new LambdaTest();
  4.         lt.LambdaTest();
  5.     }
  7.     public void LambdaTest() {
  9.         //把函数作为一个方法的参数
  10.         // 类型声明
  11.         System.out.println("4 + 2 = " + operate(4, 2, (int a, int b) -> a + b));
  12.         // 不用类型声明
  13.         System.out.println("4 - 2 = " + operate(4, 2, (a, b) -> a - b));
  14.         // 大括号中的返回语句
  15.         System.out.println("4 x 2 = " + operate(4, 2, (int a, int b) -> {
  16.             return a * b;
  17.         }));
  18.         // 省略大括号及返回语句
  19.         System.out.println("4 / 2 = " + operate(4, 2, (int a, int b) -> a / b));
  21.         // 不用括号
  22.         Service service1 = x ->
  23.                 System.out.println("hi!" + x);
  24.         // 用括号
  25.         Service service2 = (x) ->
  26.                 System.out.println("hello!" + x);
  27.         service1.say("zhangsan");
  28.         service2.say("lisi");
  29.     }
  31.     interface MathOperation {
  32.         int operation(int a, int b);
  33.     }
  35.     interface Service {
  36.         void say(String message);
  37.     }
  39.     private int operate(int a, int b, MathOperation mathOperation) {
  40.         return mathOperation.operation(a, b);
  41.     }
  42. }

输出：

  1. 4 + 2 = 6
  2. 4 - 2 = 2
  3. 4 x 2 = 8
  4. 4 / 2 = 2
  5. hi!zhangsan
  6. hello!lisi

4. 方法引用

方法引用通过方法的名字来指向一个方法。
方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
方法引用使用一对冒号 :: 。
实例：

  1. public class MethodReferenceTest {
  3.     public void commonMethod(String name) {
  4.         System.out.println("my name is " + name);
  5.     }
  7.     public static void main(String[] args) {
  8.         /**
  9.          * 1.静态方法引用
  10.          * */
  11.         Arrays.asList("a", "b", "c", "d").stream().forEach(MethodReferenceTest::staticMethod);
  13.         /**
  14.          * 2.构造器引用
  15.          *         构造器引用适用于lambda表达式主体中仅仅调用了某个类的构造函数返回实例的场景。
  16.          * */
  17.         //  Supplier<List<String>> supplier = ArrayList::new;
  18.         MethodReferenceTest mr = MethodReferenceTest.create(MethodReferenceTest::new);
  20.         /** 3.类的任意对象的实例方法引用
  21.          * 方法引用的通用特性：方法引用所使用方法的入参和返回值与lambda表达式实现的函数式接口的入参和返回值一致；
  22.          * lambda表达式的第一个入参为实例方法的调用者，后面的入参与实例方法的入参一致。
  23.          * */
  24.         TestInterface testInterface = MethodReferenceTest::commonMethod;
  25.         testInterface.set(new MethodReferenceTest(), "张三");
  26.         /**
  27.          * 特定对象的实例方法引用
  28.          * 特定对象的实例方法引用适用于lambda表达式的主体中仅仅调用了某个对象的某个实例方法的场景。
  29.          * */
  30.         MethodReferenceTest test = new MethodReferenceTest();
  31.         Arrays.asList("a", "b", "c", "d").stream().forEach(test::commonMethod);
  32.     }
  34.     public static void staticMethod(String s) {
  35.         System.out.println(s);
  36.     }
  38.     //Supplier是jdk1.8的接口，这里和lamda一起使用了
  39.     public static MethodReferenceTest create(final Supplier<MethodReferenceTest> supplier) {
  40.         return supplier.get();
  41.     }
  43.     @FunctionalInterface
  44.     interface TestInterface {
  45.         // 注意：入参比MethodReferenceTest类的set方法多1个MethodReferenceTest对象，除第一个外其它入参类型一致
  46.         void set(MethodReferenceTest mt, String name);
  47.     }
  48. }

5.默认方法

Java 8 新增了接口的默认方法。
简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。
我们只需在方法名前面加个default关键字即可实现默认方法。
为什么要有这个特性？
首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的java 8之前的集合框架没有foreach方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。
一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法：

  1. public class Car implements vehicle, fourWheeler {
  2.     /**
  3.      * 用super指定接口默认方法
  4.      * */
  5.   /*  @Override
  6.     public void print() {
  7.         vehicle.super.print();
  8.     }*/
  10.     /**
  11.      * 创建自己的默认方法，来覆盖重写接口的默认方法：
  12.      */
  13.     @Override
  14.     public void print() {
  15.         System.out.println("四轮汽车");
  16.     }
  17. }
  19. interface vehicle {
  20.     default void print() {
  21.         System.out.println("我是一辆车!");
  22.     }
  23. }
  25. interface fourWheeler {
  26.     default void print() {
  27.         System.out.println("我是一辆四轮车!");
  28.     }
  29. }