1）接口默认方法和 静态方法

Java 8用默认方法与静态方法这两个新概念来扩展接口的声明。与传统的接口又有些不一样，它允许在已有的接口中添加新方法，而同时又保持了与旧版本代码的兼容性。

1.接口默认方法

默认方法与抽象方法不同之处在于抽象方法必须要求实现，但是默认方法则没有这个要求。相反，每个接口都必须提供一个所谓的默认实现，这样所有的接口实现者将会默认继承它（如果有必要的话，可以覆盖这个默认实现）。让我们看看下面的例子：

private interface Defaulable { 
 // Interfaces now allow default methods, the implementer may o
 // may not implement (override) them.
 default String notRequired() {
 return "Default implementation";
 }
}

private static class DefaultableImpl implements Defaulable { 
}

private static class OverridableImpl implements Defaulable { 
 @Override
 public String notRequired() {
 return "Overridden implementation";
 }
} 

Defaulable 接口用关键字 default 声明了一个默认方法 notRequired()，Defaulable 接口的实现者之一 DefaultableImpl 实现了这个接口，并且让默认方法保持原样。Defaulable 接口的另一个实现者 OverridableImpl 用自己的方法覆盖了默认方法。

1.1 多重继承的冲突说明：

由于同一个方法可以从不同的接口引入，自然而然的会有冲突的现象，规则如下：

• 一个声明在类里面的方法优先于任何默认方法
• 优先选取最具体的实现

public interface A {

 default void hello() {
 System.out.println("Hello A");
 }

} 
public interface B extends A {

 default void hello() {
 System.out.println("Hello B");
 }

} 
public class C implements A, B {

 public static void main(String[] args) {
 new C().hello(); // 输出 Hello B
 }

 

1.2 优缺点：

• 优点 : 可以在不破坏代码的前提下扩展原有库的功能。它通过一个很优雅的方式使得接口变得更智能，同时还避免了代码冗余，并且扩展类库。
• 缺点 : 使得 接口作为协议，类作为具体实现 的界限开始变得有点模糊。

1.3 接口默认方法不能重载Object类的任何方法：

接口不能提供对Object类的任何方法的默认实现。 简单地讲，每一个 Java 类都是Object的子类，也都继承了它类中的 equals()/hashCode()/toString() 方法，那么在类的接口上包含这些默认方法是没有意义的，它们也从来不会被编译。

在 JVM 中，默认方法的实现是非常高效的，并且通过字节码指令为方法调用提供了支持。默认方法允许继续使用现有的Java接口，而同时能够保障正常的编译过程。这方面好的例子是大量的方法被添加到 java.util.Collection 接口中去：stream()，parallelStream()，forEach()，removeIf() 等。尽管默认方法非常强大，但是在使用默认方法时我们需要小心注意一个地方：在声明一个默认方法前，请仔细思考是不是真的有必要使用默认方法。

2.接口静态方法

Java 8 带来的另一个有趣的特性是接口可以声明（并且可以提供实现）静态方法。在接口中定义静态方法，使用 static 关键字，例如：

public interface StaticInterface {

 static void method() {
 System.out.println("这是Java8接口中的静态方法!");
 }

} 

下面的一小段代码是上面静态方法的使用。

public class Main {

 public static void main(String[] args) {
 StaticInterface.method(); // 输出 这是Java8接口中的静态方法!
 }

} 

Java 支持一个实现类可以实现多个接口，如果多个接口中存在同样的 static 方法会怎么样呢？如果有两个接口中的静态方法一模一样，并且一个实现类同时实现了这两个接口，此时并不会产生错误，因为Java8中只能通过接口类调用接口中的静态方法，所以对编译器来说是可以区分的。

2）Lambda 表达式

Lambda 表达式（也称为闭包）是整个Java 8发行版中最受期待的在Java语言层面上的改变，Lambda允许把函数作为一个方法的参数（即： 行为参数化 ，函数作为参数传递进方法中）。

一个 Lambda 可以由用逗号分隔的参数列表、–> 符号与函数体三部分表示。

首先看看在老版本的Java中是如何排列字符串的：

List names = Arrays.asList("peter", "anna", "mike", "xenia"); 
Collections.sort(names, new Comparator() {

 @Override
 public int compare(String a, String b) {
 return b.compareTo(a);
 }

}); 

只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法， Lambda表达式 ：

Collections.sort(names, (String a, String b) -> { 
 return b.compareTo(a);
}); 

看到了吧，代码变得更短且更具有可读性，但是实际上还可以写得更短：

Collections.sort(names, (String a, String b) -> b.compareTo(a));  

对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：

Collections.sort(names, (a, b) -> b.compareTo(a));  

Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。

更多 Lambda 表达式的示例在这里：Java8 lambda表达式10个示例

3）函数式接口

Lambda 表达式是如何在 Java 的类型系统中表示的呢？每一个Lambda表达式都对应一个类型，通常是接口类型。而 函数式接口 是指仅仅只包含一个抽象方法的接口，每一个该类型的Lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。

我们可以将Lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

示例如下：

@FunctionalInterface
interface Converter { 
 T convert(F from);
}

Converter converter = (from) -> Integer.valueOf(from); 
Integer converted = converter.convert("123"); 
System.out.println(converted); // 123  

注意： 如果 @FunctionalInterface 如果没有指定，上面的代码也是对的。

更多参考： Java 8——Lambda表达式、Java8新特性及使用

4）方法引用

1.概述：

在学习了Lambda表达式之后，我们通常使用Lambda表达式来创建匿名方法。然而，有时候我们仅仅是调用了一个已存在的方法。如下：

Arrays.sort(strArray, (s1, s2) -> s1.compareToIgnoreCase(s2));  

在Java8中，我们可以直接通过方法引用来简写Lambda表达式中已经存在的方法。

Arrays.sort(strArray, String::compareToIgnoreCase);  

这种特性就叫做 方法引用 (Method Reference)。

方法引用 是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式。

注意 : 方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号::。

2.分类：

方法引用的标准形式是：类名::方法名。（注意：只需要写方法名，不需要写括号）

有以下四种形式的方法引用：

• 引用静态方法: ContainingClass::staticMethodName
• 引用某个对象的实例方法: containingObject::instanceMethodName
• 引用某个类型的任意对象的实例方法:ContainingType::methodName
• 引用构造方法: ClassName::new

3.示例：

使用示例如下：

public class Person {

 String name;

 LocalDate birthday;

 public Person(String name, LocalDate birthday) {
  this.name = name;
  this.birthday = birthday;
 }

 public LocalDate getBirthday() {
  return birthday;
 }

 public static int compareByAge(Person a, Person b) {
  return a.birthday.compareTo(b.birthday);
 }

 @Override
 public String toString() {
  return this.name;
 }
} 
public class MethodReferenceTest {

 @Test
 public static void main() {
 Person[] pArr = new Person[] {
  new Person("003", LocalDate.of(2016,9,1)),
  new Person("001", LocalDate.of(2016,2,1)),
  new Person("002", LocalDate.of(2016,3,1)),
  new Person("004", LocalDate.of(2016,12,1))
 };

 // 使用匿名类
 Arrays.sort(pArr, new Comparator() {
  @Override
  public int compare(Person a, Person b) {
   return a.getBirthday().compareTo(b.getBirthday());
  }
 });

 //使用lambda表达式
 Arrays.sort(pArr, (Person a, Person b) -> {
  return a.getBirthday().compareTo(b.getBirthday());
 });

 //使用方法引用，引用的是类的静态方法
 Arrays.sort(pArr, Person::compareByAge);
 }

} 

5）Steam

Java8添加的 Stream API(java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为 Stream API 可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。使用 Steam 写出来的代码真的能让人兴奋，这里链出之前的一篇文章：Java 8——函数式数据处理（流）

流可以是无限的、有状态的，可以是顺序的，也可以是并行的。在使用流的时候，你首先需要从一些来源中获取一个流，执行一个或者多个中间操作，然后执行一个最终操作。中间操作包括filter、map、flatMap、peel、distinct、sorted、limit 和 substream。终止操作包括 forEach、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst 和 findAny。java.util.stream.Collectors 是一个非常有用的实用类。该类实现了很多归约操作，例如将流转换成集合和聚合元素。

1.一些重要方法说明：

• stream: 返回数据流，集合作为其源
• parallelStream: 返回并行数据流， 集合作为其源
• filter: 方法用于过滤出满足条件的元素
• map: 方法用于映射每个元素对应的结果
• forEach: 方法遍历该流中的每个元素
• limit: 方法用于减少流的大小
• sorted: 方法用来对流中的元素进行排序
• anyMatch: 是否存在任意一个元素满足条件（返回布尔值）
• allMatch: 是否所有元素都满足条件（返回布尔值）
• noneMatch: 是否所有元素都不满足条件（返回布尔值）
• collect: 方法是终端操作，这是通常出现在管道传输操作结束标记流的结束

2.一些使用示例：

2.1 Filter 过滤：

stringCollection 
 .stream()
 .filter((s) -> s.startsWith("a"))
 .forEach(System.out::println); 

2.2 Sort 排序：

stringCollection 
 .stream()
 .sorted()
 .filter((s) -> s.startsWith("a"))
 .forEach(System.out::println); 

2.3 Map 映射：

stringCollection 
 .stream()
 .map(String::toUpperCase)
 .sorted((a, b) -> b.compareTo(a))
 .forEach(System.out::println); 

2.4 Match 匹配：

boolean anyStartsWithA = stringCollection 
 .stream()
 .anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true

boolean allStartsWithA = stringCollection 
 .stream()
 .allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false

boolean noneStartsWithZ = stringCollection 
 .stream()
 .noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true  

2.5 Count 计数：

long startsWithB = stringCollection 
 .stream()
 .filter((s) -> s.startsWith("b"))
 .count();
System.out.println(startsWithB); // 3  

2.6 Reduce 规约：

Optional reduced = stringCollection 
 .stream()
 .sorted()
 .reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);  

6）Optional

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

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

我们下面用两个小例子来演示如何使用Optional类：一个允许为空值，一个不允许为空值。

Optional fullName = Optional.ofNullable(null); 
System.out.println("Full Name is set? " + fullName.isPresent()); 
System.out.println("Full Name: " + fullName.orElseGet(() -> "[none]")); 
System.out.println(fullName.map(s -> "Hey " + s + "!").orElse("Hey Stranger!"));  

如果Optional类的实例为非空值的话，isPresent()返回true，否从返回false。为了防止Optional为空值，orElseGet()方法通过回调函数来产生一个默认值。map()函数对当前Optional的值进行转化，然后返回一个新的Optional实例。orElse()方法和orElseGet()方法类似，但是orElse接受一个默认值而不是一个回调函数。下面是这个程序的输出：

Full Name is set? false 
Full Name: [none] 
Hey Stranger!  

让我们来看看另一个例子：

Optional firstName = Optional.of("Tom"); 
System.out.println("First Name is set? " + firstName.isPresent()); 
System.out.println("First Name: " + firstName.orElseGet(() -> "[none]")); 
System.out.println(firstName.map(s -> "Hey " + s + "!").orElse("Hey Stranger!")); 
System.out.println();  

下面是程序的输出：

First Name is set? true 
First Name: Tom 
Hey Tom!  

7）Date/Time API

Java 8 在包java.time下包含了一组全新的时间日期API。新的日期API和开源的Joda-Time库差不多，但又不完全一样，下面的例子展示了这组新API里最重要的一些部分：

1.Clock 时钟：

Clock类提供了访问当前日期和时间的方法，Clock是时区敏感的，可以用来取代System.currentTimeMillis()来获取当前的微秒数。某一个特定的时间点也可以使用Instant类来表示，Instant类也可以用来创建老的java.util.Date对象。代码如下:

Clock clock = Clock.systemDefaultZone(); 
long millis = clock.millis(); 
Instant instant = clock.instant(); 
Date legacyDate = Date.from(instant); // legacy java.util.Date  

2.Timezones 时区：

在新API中时区使用ZoneId来表示。时区可以很方便的使用静态方法of来获取到。时区定义了到UTS时间的时间差，在Instant时间点对象到本地日期对象之间转换的时候是极其重要的。代码如下:

System.out.println(ZoneId.getAvailableZoneIds()); 
// prints all available timezone ids
ZoneId zone1 = ZoneId.of("Europe/Berlin"); 
ZoneId zone2 = ZoneId.of("Brazil/East"); 
System.out.println(zone1.getRules()); 
System.out.println(zone2.getRules()); 
// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00] 

3.LocalTime 本地时间：

LocalTime定义了一个没有时区信息的时间，例如 晚上10点，或者 17:30:15。下面的例子使用前面代码创建的时区创建了两个本地时间。之后比较时间并以小时和分钟为单位计算两个时间的时间差。代码如下:

LocalTime now1 = LocalTime.now(zone1); 
LocalTime now2 = LocalTime.now(zone2); 
System.out.println(now1.isBefore(now2)); // false 
long hoursBetween = ChronoUnit.HOURS.between(now1, now2); 
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2); 
System.out.println(hoursBetween); // -3 
System.out.println(minutesBetween); // -239  

LocalTime提供了多种工厂方法来简化对象的创建，包括解析时间字符串。代码如下:

LocalTime late = LocalTime.of(23, 59, 59); 
System.out.println(late); // 23:59:59 
DateTimeFormatter germanFormatter = DateTimeFormatter 
 .ofLocalizedTime(FormatStyle.SHORT)
 .withLocale(Locale.GERMAN);
LocalTime leetTime = LocalTime.parse("13:37", germanFormatter); 
System.out.println(leetTime); // 13:37  

4.LocalDate 本地日期：

LocalDate表示了一个确切的日期，比如2014-03-11。该对象值是不可变的，用起来和LocalTime基本一致。下面的例子展示了如何给Date对象加减天/月/年。另外要注意的是这些对象是不可变的，操作返回的总是一个新实例。代码如下:

LocalDate today = LocalDate.now(); 
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS); 
LocalDate yesterday = tomorrow.minusDays(2); 
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4); 
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();

System.out.println(dayOfWeek); // FRIDAY  

从字符串解析一个LocalDate类型和解析LocalTime一样简单。代码如下:

DateTimeFormatter germanFormatter = DateTimeFormatter 
 .ofLocalizedDate(FormatStyle.MEDIUM)
 .withLocale(Locale.GERMAN);
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter); 
System.out.println(xmas); // 2014-12-24  

5.LocalDateTime 本地日期时间：

LocalDateTime同时表示了时间和日期，相当于前两节内容合并到一个对象上了。LocalDateTime和LocalTime还有LocalDate一样，都是不可变的。LocalDateTime提供了一些能访问具体字段的方法。代码如下:

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59); 
DayOfWeek dayOfWeek = sylvester.getDayOfWeek(); 
System.out.println(dayOfWeek); // WEDNESDAY 
Month month = sylvester.getMonth(); 
System.out.println(month); // DECEMBER 
long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY); 
System.out.println(minuteOfDay); // 1439  

只要附加上时区信息，就可以将其转换为一个时间点Instant对象，Instant时间点对象可以很容易的转换为老式的java.util.Date。代码如下:

Instant instant = sylvester 
 .atZone(ZoneId.systemDefault())
 .toInstant();
Date legacyDate = Date.from(instant); 
System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014  

格式化LocalDateTime和格式化时间和日期一样的，除了使用预定义好的格式外，我们也可以自己定义格式。代码如下:

DateTimeFormatter formatter = 
 DateTimeFormatte
 .ofPattern("MMM dd, yyyy - HH:mm");
LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter); 
String string = formatter.format(parsed); 
System.out.println(string); // Nov 03, 2014 - 07:13  

和java.text.NumberFormat不一样的是新版的DateTimeFormatter是不可变的，所以它是线程安全的。

关于Java8中日期API更多的使用示例可以参考Java 8中关于日期和时间API的20个使用示例。

8）重复注解

自从Java 5引入了注解机制，这一特性就变得非常流行并且广为使用。然而，使用注解的一个限制是相同的注解在同一位置只能声明一次，不能声明多次。Java 8打破了这条规则，引入了重复注解机制，这样相同的注解可以在同一地方声明多次。

重复注解机制本身必须用@Repeatable注解。事实上，这并不是语言层面上的改变，更多的是编译器的技巧，底层的原理保持不变。让我们看一个快速入门的例子：

import java. lang . annotation .ElementType; 
import java.lang.annotation.Repeatable; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target;

public class RepeatingAnnotations {

 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Filters {
  Filter[] value();
 }

 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Repeatable(Filters.class)
 public @interface Filter {
  String value();
 };

 @Filter("filter1")
 @Filter("filter2")
 public interface Filterable {
 }

 public static void main(String[] args) {
  for(Filter filter: Filterable.class.getAnnotationsByType(Filter.class)) {
   System.out.println(filter.value());
  }
 }

} 

正如我们看到的，这里有个使用@Repeatable(Filters.class)注解的注解类Filter，Filters仅仅是Filter注解的数组，但Java编译器并不想让程序员意识到Filters的存在。这样，接口Filterable就拥有了两次Filter（并没有提到Filter）注解。

同时，反射相关的API提供了新的函数getAnnotationsByType()来返回重复注解的类型（请注意Filterable.class.getAnnotation(Filters.class)经编译器处理后将会返回Filters的实例）。

9）扩展注解的支持

Java 8扩展了注解的上下文。现在几乎可以为任何东西添加注解：局部变量、泛型类、父类与接口的实现，就连方法的异常也能添加注解。下面演示几个例子：

import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 
import java.util.ArrayList; 
import java.util.Collection;

public class Annotations {

 @Retention(RetentionPolicy.RUNTIME)
 @Target({ ElementType.TYPE_USE, ElementType.TYPE_PARAMETER })
 public @interface NonEmpty {
 }

 public static class Holder<@NonEmpty T> extends @NonEmpty Object {
  public void method() throws @NonEmpty Exception {
  }
 }

 @SuppressWarnings("unused")
 public static void main(String[] args) {
  final Holder holder = new @NonEmpty Holder();
  @NonEmpty Collection<@NonEmpty String> strings = new ArrayList<>();
 }

} 

10）Base 64

在Java 8中，Base64编码已经成为Java类库的标准。它的使用十分简单，下面让我们看一个例子：

import java.nio.charset.StandardCharsets; 
import java.util.Base64;

public class Base64s {

 public static void main(String[] args) {
  final String text = "Base64 finally in Java 8!";

  final String encoded = Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
  System.out.println(encoded);

  final String decoded = new String(Base64.getDecoder().decode(encoded), StandardCharsets.UTF_8);
  System.out.println(decoded);
 }

} 

程序在控制台上输出了编码后的字符与解码后的字符：

QmFzZTY0IGZpbmFsbHkgaW4gSmF2YSA4IQ== 
Base64 finally in Java 8!  

Base64类同时还提供了对URL、MIME友好的编码器与解码器（Base64.getUrlEncoder() / Base64.getUrlDecoder(), Base64.getMimeEncoder() / Base64.getMimeDecoder()）。

11）JavaFX

JavaFX是一个强大的图形和多媒体处理工具包集合，它允许开发者来设计、创建、测试、调试和部署富客户端程序，并且和Java一样跨平台。从Java8开始，JavaFx已经内置到了JDK中。关于JavaFx更详细的文档可参考JavaFX中文文档。

12）HashMap的底层实现有变化

Java8中，HashMap内部实现又引入了红黑树（数组+链表+红黑树），使得HashMap的总体性能相较于Java7有比较明显的提升。

13）JVM内存管理方面，由元空间代替了永久代。

区别：

1. 元空间并不在虚拟机中，而是使用本地内存
2. 默认情况下，元空间的大小仅受本地内存限制
3. 也可以通过-XX：MetaspaceSize指定元空间大小

（五）Java 9 相关知识点

引用自文章：Java 9 中的 9 个新特性、Java 9 新特性概述——IBM、【译】使用示例带你提前了解 Java 9 中的新特性

1）Java 9 PEPK（JShell）

Oracle 公司（Java Library 开发者）新引进一个代表 Java Shell 的称之为 “jshell” 或者 REPL（Read Evaluate Print Loop）的新工具。该工具可以被用来执行和测试任何 Java 中的结构，如 class，interface，enum，object，statements 等。使用非常简单。

JDK 9 EA（Early Access）下载地址：

G:>jshell
| Welcome to JShell -- Version 9-ea
| For an introduction type: /help intro
jshell> int a = 10
a ==> 10
jshell> System.out.println("a value = " + a )
a value = 10 

2）集合工厂方法

通常，您希望在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。实例化集合，几个 “add” 调用，使得代码重复。Java 9，添加了几种集合工厂方法：

Set ints = Set.of(1, 2, 3);
List strings = List.of("first", "second"); 

除了更短和更好阅读之外，这些方法也可以避免您选择特定的集合实现。事实上，从工厂方法返回已放入数个元素的集合实现是高度优化的。这是可能的，因为它们是不可变的：在创建后，继续添加元素到这些集合会导致 “UnsupportedOperationException” 。

3）接口中的私有方法

在 Java 8 中，我们可以在接口中使用默认或者静态方法提供一些实现方式，但是不能创建私有方法。

为了避免冗余代码和提高重用性，Oracle 公司准备在 Java SE 9 接口中引入私有方法。也就是说从 Java SE 9 开始，我们也能够在接口类中使用 ‘private’ 关键字写私有化方法和私有化静态方法。

接口中的私有方法与 class 类中的私有方法在写法上并无差异，如：

public interface Card{
 private Long createCardID(){
 // Method implementation goes here.
 }
 private static void displayCardDetails(){
 // Method implementation goes here.
 }
} 

4）Java 平台级模块系统

这里只给出解决的问题，仅限了解….

Java 9 的定义功能是一套全新的模块系统。当代码库越来越大，创建复杂，盘根错节的“意大利面条式代码”的几率呈指数级的增长。这时候就得面对两个基础的问题: 很难真正地对代码进行封装, 而系统并没有对不同部分（也就是 JAR 文件）之间的依赖关系有个明确的概念。每一个公共类都可以被类路径之下任何其它的公共类所访问到, 这样就会导致无意中使用了并不想被公开访问的 API。此外，类路径本身也存在问题: 你怎么知晓所有需要的 JAR 都已经有了, 或者是不是会有重复的项呢? 模块系统把这俩个问题都给解决了。

5）进程 API

Java SE 9 迎来一些 Process API 的改进，通过添加一些新的类和方法来优化系统级进程的管控。

Process API 中的两个新接口：

• java.lang.ProcessHandle
• java.lang.ProcessHandle.Info

Process API 示例

ProcessHandle currentProcess = ProcessHandle.current();
System.out.println("Current Process Id: = " + currentProcess.getPid()); 

6）Try With Resources Improvement

我们知道，Java SE 7 引入了一个新的异常处理结构：Try-With-Resources，来自动管理资源。这个新的声明结构主要目的是实现“Automatic Better Resource Management”（“自动资源管理”）。

Java SE 9 将对这个声明作出一些改进来避免一些冗长写法，同时提高可读性。

Java SE 7 示例

void testARM_Before_Java9() throws IOException {
 BufferedReader reader1 = new BufferedReader(new FileReader("journaldev.txt"));
 try (BufferedReader reader2 = reader1) {
  System.out.println(reader2.readLine());
 }
} 

Java SE 9 示例

void testARM_Java9() throws IOException {
 BufferedReader reader1 = new BufferedReader(new FileReader("journaldev.txt"));
 try (reader1) {
  System.out.println(reader1.readLine());
 }
} 

7）CompletableFuture API Improvements

在 Java SE 9 中，Oracle 公司将改进 CompletableFuture API 来解决一些 Java SE 8 中出现的问题。这些被添加的 API 将用来支持一些延时和超时操作，实用方法和更好的子类化。

Executor exe = CompletableFuture.delayedExecutor(50L, TimeUnit.SECONDS); 

这里的 delayedExecutor() 是静态实用方法，用来返回一个在指定延时时间提交任务到默认执行器的新 Executor 对象。

8）反应式流 （ Reactive Streams ）

反应式编程的思想最近得到了广泛的流行。在 Java 平台上有流行的反应式 库 RxJava 和 R eactor。反应式流规范的出发点是提供一个带非阻塞负压（ non-blocking backpressure ） 的异步流处理规范。反应式流规范的核心接口已经添加到了 Java9 中的 java.util.concurrent.Flow 类中。

Flow 中包含了 Flow.Publisher、Flow.Subscriber、Flow.Subscription 和 F low.Processor 等 4 个核心接口。Java 9 还提供了 SubmissionPublisher 作为 Flow.Publisher 的一个实现。RxJava 2 和 Reactor 都可以很方便的 与 Flow 类的核心接口进行互操作。

9）改进的 Stream API

长期以来，Stream API 都是 Java 标准库最好的改进之一。通过这套 API 可以在集合上建立用于转换的申明管道。在 Java 9 中它会变得更好。Stream 接口中添加了 4 个新的方法：dropWhile, takeWhile, ofNullable。还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代：

IntStream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::println); 

第二个参数是一个 Lambda，它会在当前 IntStream 中的元素到达 100 的时候返回 true。因此这个简单的示例是向控制台打印 1 到 99。

除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 stram 将一个 Optional 对象转换为一个(可能是空的) Stream 对象：

Stream s = Optional.of(1).stream(); 

在组合复杂的 Stream 管道时，将 Optional 转换为 Stream 非常有用。

10）HTTP/2

Java 9 中有新的方式来处理 HTTP 调用。这个迟到的特性用于代替老旧的 HttpURLConnectionAPI，并提供对 WebSocket 和 HTTP/2 的支持。注意：新的 HttpClient API 在 Java 9 中以所谓的孵化器模块交付。也就是说，这套 API 不能保证 100% 完成。不过你可以在 Java 9 中开始使用这套 API：

HttpClient client = HttpClient.newHttpClient();

HttpRequest req =
 HttpRequest.newBuilder(URI.create(""))
 .header("User-Agent","Java")
 .GET()
 .build();

HttpResponse resp = client.send(req, HttpResponse.BodyHandler.asString()); 

HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandler.asString());

除了这个简单的请求/响应模型之外，HttpClient 还提供了新的 API 来处理 HTTP/2 的特性，比如流和服务端推送。

11）Optional Class Improvements

在 Java SE 9 中，Oracle 公司添加了一些新的实用方法到 java.util.Optional 类里面。这里我将使用一些简单的示例来描述其中的一个：stream 方法。

如果一个值出现在给定 Optional 对象中，stream() 方法可以返回包含该值的一个顺序 Stream 对象。否则，将返回一个空 Stream。

stream() 方法已经被添加，并用来在 Optional 对象中使用，如：

Stream emp = getEmployee(id)
Stream empStream = emp.flatMap(Optional::stream) 

这里的 Optional.stream() 方法被用来转化 Employee 可选流对象 到 Employee 流中，如此我们便可以在后续代码中使用这个结果。

12）多版本兼容 JAR

我们最后要来着重介绍的这个特性对于库的维护者而言是个特别好的消息。当一个新版本的 Java 出现的时候，你的库用户要花费数年时间才会切换到这个新的版本。这就意味着库得去向后兼容你想要支持的最老的 Java 版本 (许多情况下就是 Java 6 或者 7)。这实际上意味着未来的很长一段时间，你都不能在库中运用 Java 9 所提供的新特性。幸运的是，多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本：

multirelease.ja
├── META-INF
│ └── versions
│ └── 9
│ └── multirelease
│ └── Helper.class
├── multirelease
 ├── Helper.class
 └── Main.class 

在上述场景中， multirelease.jar 可以在 Java 9 中使用, 不过 Helper 这个类使用的不是顶层的 multirelease.Helper 这个 class, 而是处在“META-INF/versions/9”下面的这个。这是特别为 Java 9 准备的 class 版本，可以运用 Java 9 所提供的特性和库。同时，在早期的 Java 诸版本中使用这个 JAR 也是能运行的，因为较老版本的 Java 只会看到顶层的这个 Helper 类。