再来看看Java的新特性——其他新特性

关于剩余Java8新特性知识点总结，包含：默认方法、Optional、CompletableFuture、时间相关。

默认方法

默认方法皆在帮助Java新功能可以兼容低版本JDK已开发的程序。 比如说，给一个低版本已存在的接口增加新方法，那原来实现该接口的类是不是都需要实现新的方法，这非常不友好，也不利于项目JDK版本的升级，所以引入新的规则默认方法。

使用方法也非常简单，只需要在接口方法前加上关键字default，然后再将其实现之就好了。

public interface Parent {
    default void hello(){
        System.out.println("hello");
    }
}
public class Son implements Parent {
    public static void main(String[] args) {
        Son son = new Son();
        son.hello();
    }
}

默认方法很好的解决了菱形继承的问题，虽然Java是单继承，一般情况下不会出现这种问题，但是别忘了Java除了继承，还有实现，假设有一下这种情况。

Son实现了Parent、Parent1，Parent和Parent1都继承了GrandParent，而GrandParent中有一个抽象方法hello，然后Son就会报错。而如果将GrandParent中的方法改成默认方法，这个为你就解决了。

//这种方式，Son会报错
public interface GrandParent {
     void hello();
}
//这种方式就ok了
public interface GrandParent {
    default void hello(){
        System.out.println("hello");
    }
}

其实有了默认方法，一个Java类可以实现N多个接口，无论它们多么错综复杂。但是为了代码层次，最好使用代理模式，提前实现一层代理类封装好所有的接口，真正继承的类再去继承代理类，这样使用起来就会很舒服了。

Optional

但凡写过Java的同学，一定知道null的存在，null是那些从未定义对象的指向。为了避免NullPointerException的出现，代码中要加大量的if判断。为了让这种冗余的无意义的代码消失，为了更加符合Java设计哲学，Optional应运而生。

Optional就是将用户创建的对象再进一步封装，使用户对象只是Optional对象的一部分，这样对于开发人员层面来说，就不会直接操作未定义的对象了。

创建Optional

假设我们的用户类就是上一节中的Son。创建一个包含Son对象的Optional，并且Son对象目前指向为null。使用静态方法Optional.empty()。

Optional<Son> optCar = Optional.empty();

接着将存在的用户对象Son放到Optional中。

Son son = new Son();
Optional<Son> sonOptional = Optional.of(son);

不过使用Optional.of需要保证参数必须不为null，否则就会抛出NullPointerException 异常，为了解决这个问题，可以使用下面这个方法。

Optional<Son> sonOptional = Optional.ofNullable(son);

Optional结合流操作

不仅仅是判空问题，Optional可以天然的和Stream结合。为了方便，我们给Son类增加属性name、age。

@Data
public class Son implements Parent,Parent2 {
    private String name;
    private Integer age;
}

现在假设我们需要知道son的name，首先需要判断son是否为空，再使用方法son.getName()对吧。然而有了Optional我们可以使用map这么写。

//原始写法
Son son = null;
if(Objects.nonNull()){
    String name = son.getName();
}
//新写法
Son son = null;
Optional<Son> sonOptional = Optional.of(son);
Optional<String> name = sonOptional.map(Son::getName);

值得一提的是通过Stream操作转化来的对象还是Optional，只不过泛型变成了预期值类型。

Optional嵌套问题

如果看过我上篇写的Stream的博客，那么除了map,你一定还记得flatMap ， flatMap 可以合并Stream，同样的 flatMap 可以将多个嵌套的Optional进行合并。下面举个例子说明一下，为了说明问题新建两个类Computer、CPU，显而易见CPU是Computer的一部分。我们需要知道某品牌电脑CPU的生产厂家。

@Data
public class CPU {
    private String name;
    private String manufacturers;
}
@Data
public class Computer {
    private String name;
    private Optional<CPU> cpu;
}

首先使用map看一下效果。

Optional<Computer> optionalComputer = Optional.of(computer);
Optional<String> stringOptional = optionalComputer
    .map(Computer::getCpu)
    .map(CPU::getManufacturers);//别说运行了，这行编译失败
System.out.println(stringOptional.get());

第4行编译失败，那是因为经历第3行，此时对象的结构为Optional<Optional<CPU>>，此时的泛型是Optional<CPU>，无法直接调用CPU::getManufacturers。

所以就需要使用flatMap 将两层Optional合并。

Optional<Computer> optionalComputer = Optional.of(computer);
Optional<String> stringOptional = optionalComputer
    .flatMap(Computer::getCpu)
    .map(CPU::getManufacturers);

ok,完美执行了。当然了，Stream中有很多方法这里都适用，比如filter。

Optional数据读取

最直接的方法就是get(),但是get()方法需要提前判空，如果用户对象(就是泛型类的对象)为null，get()方法就会报错。

stringOptional.get()

当然，你要执意使用get()方法，Java也提供了更友好的方法orElse()，这个方法可以当对象是空的时候，给一个默认值。

stringOptional.orElse("juejin")

对于orElse()，还有一个升级版本的方法orElseGet(),是orElse()延时版本，当只有使用默认值的时候，才会运算orElseGet()的参数，这样就避免了默认值是耗时操作影响性能。

stringOptional.orElseGet(()->"juejin")

如果你想在对象不存在的时候，抛出一个异常，就可以使用方法orElseThrow()。

stringOptional.orElseThrow(Exception::new)

还有一个非常好用的方法ifPresent()，这个方法可以判断对象是否存在。

if (stringOptional.isPresent()){
	System.out.println("stringOptional.isPresent()");
}

CompletableFuture

写过一篇《强大的CompletableFuture》。

新的日期API

虽说现在有很多成型的第三方工具包，例如Hutool。处理时间问题多了很多选择，但是JDK本身的方法，不仅提供了某种意义上的最佳实践，还让代码侵入性几乎为零。

LocalDate 和 LocalTime

相信很多使用过Java8的小伙伴都用过LocalDateTime，没错，就是LocalDate和LocalTime 的结合形式，分别控制着年月日、时分秒。

LocalDate localDate = LocalDate.of(2019,11,24);
localDate.getYear();
localDate.getMonth();
localDate.getDayOfYear();
LocalTime localTime = LocalTime.of(18,40,03);
localTime.getHour();
localTime.getMinute();
localTime.getSecond();

这两个方法比较简单，可以灵活的对年月日、时分秒进行读取和操作。然而真正使用多的是他们的结合版本LocalDateTime。

Instant

这个类可以获取机器时间，就是从1970年开始计算的时间，举例获取时间戳。

Instant instant = Instant.now();
System.out.println(instant.getEpochSecond());

当然getEpochSecond()这个方法还可以传参数，相对于当前时间位移一定的时间间隔。

Duration 或 Period

Duration可以获取两个时间之间的间隔。

Duration d1 = Duration.between(time1, time2);
Duration d1 = Duration.between(dateTime1, dateTime2);
Duration d2 = Duration.between(instant1, instant2);

其中参数可以是 LocalTimes 、 LocalDateTimes 、 Instant。以上可以计算秒和纳秒之间的大小。

如果需要计算年、月、日之间的时间间隔，就需要用Period。

Period tenDays = Period.between(LocalDate.of(2014, 3, 8),
 								LocalDate.of(2014, 3, 18));

时间操作

就拿LocalDateTimes举例吧，这个用的最多，新的时间类型可以快捷的对时间进行修改。

LocalDateTime localDateTime = LocalDateTime.now();
//直接修改时间，不对原始数据操作，生成新的对象。
localDateTime.withHour(1).withMonth(1);
//通过位移修改时间，不对原始数据操作，生成新的对象。
localDateTime.plusDays(12);
localDateTime.plusMinutes(33);

TemporalAdjuster

除了显示的修改时间，还可以用JDK提供的一些提前定义好的方法。

import static java.time.temporal.TemporalAdjusters.*;//注意需要这么导入
LocalDate date1 = LocalDate.of(2019, 11, 24);
System.out.println(date1);//2019-11-24
LocalDate date2 = date1.with(nextOrSame(DayOfWeek.SUNDAY));
System.out.println(date2);//2019-11-24
LocalDate date3 = date2.with(lastDayOfMonth());
System.out.println(date3);//2019-11-30

更多操作见下表

DateTimeFormatter

这个不必多说，将事件类型转化成String类型时，需要的样式格式。

LocalDateTime localDateTime = LocalDateTime.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:SS", 									Locale.CHINA);
System.out.println(localDateTime.format(dateTimeFormatter));
//2019-11-24 19:41:77

ZoneId

处理不同的时区，ZoneId 类替代了原来的 TimeZone 类。

LocalDateTime localDateTime = LocalDateTime.now();
ZoneId romeZone = ZoneId.of("Europe/Rome");
ZoneId shangHaiZone = ZoneId.of("Asia/Shanghai");
System.out.println(localDateTime.atZone(romeZone));
System.out.println(localDateTime.atZone(shangHaiZone));
//2019-11-24T19:52:13.105+01:00[Europe/Rome]
//2019-11-24T19:52:13.105+08:00[Asia/Shanghai]

唯一不爽的是ZoneId.of()参数是字符串(大洲/城市)，没有枚举类，需要开发人员手动输入。

我的公众号

我的公众号用于博客同步。