java11新特性（简述八大新特性）

1、本地变量类型推断

什么是局部变量类型推断？

var javastack = "javastack";
System.out.println(javastack);
1
2

大家看出来了，局部变量类型推断就是左边的类型直接使用 var 定义，而不用写具体的类型，编译器能根据右边的表达式自动推断类型，如上面的 String 。

var javastack = "javastack";
1

就等于：

String javastack = "javastack";
1

2、字符串加强

Java 11 增加了一系列的字符串处理方法，如以下所示。

// 判断字符串是否为空白
" ".isBlank(); // true
// 去除首尾空格
" Javastack ".strip(); // "Javastack"
// 去除尾部空格
" Javastack ".stripTrailing(); // " Javastack"
// 去除首部空格
" Javastack ".stripLeading(); // "Javastack "
// 复制字符串
"Java".repeat(3);// "JavaJavaJava"
// 行数统计
"A\nB\nC".lines().count(); // 3
1
2
3
4
5
6
7
8
9
10
11
12

3、集合加强

自 Java 9 开始，Jdk 里面为集合（List/ Set/ Map）都添加了 of 和 copyOf 方法，它们两个都用来创建不可变的集合，来看下它们的使用和区别。
示例1：

var list = List.of("Java", "Python", "C");
var copy = List.copyOf(list);
System.out.println(list == copy); // true
1
2
3

示例2：

var list = new ArrayList<String>();
var copy = List.copyOf(list);
System.out.println(list == copy); // false
1
2
3

示例1和2代码差不多，为什么一个为true,一个为false?
来看下它们的源码：

static <E> List<E> of(E... elements) {
  switch (elements.length) { // implicit null check of elements
    case 0:
        return ImmutableCollections.emptyList();
    case 1:
        return new ImmutableCollections.List12<>(elements[0]);
    case 2:
        return new ImmutableCollections.List12<>(elements[0], elements[1]);
    default:
        return new ImmutableCollections.ListN<>(elements);
  }
}
static <E> List<E> copyOf(Collection<? extends E> coll) {
    return ImmutableCollections.listCopy(coll);
}
static <E> List<E> listCopy(Collection<? extends E> coll) {
    if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {
        return (List<E>)coll;
    } else {
        return (List<E>)List.of(coll.toArray());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的，如果是，就直接返回，如果不是，则调用 of 创建一个新的集合。

示例2因为用的 new 创建的集合，不属于不可变 AbstractImmutableList 类的子类，所以 copyOf 方法又创建了一个新的实例，所以为false.

注意：使用of和copyOf创建的集合为不可变集合，不能进行添加、删除、替换、排序等操作，不然会报 java.lang.UnsupportedOperationException 异常。

上面演示了 List 的 of 和 copyOf 方法，Set 和 Map 接口都有。

    public static void main(String[] args) {
        Set<String> names = Set.of("Fred", "Wilma", "Barney", "Betty");
        //JDK11之前我们只能这么写
        System.out.println(Arrays.toString(names.toArray(new String[names.size()])));
        //JDK11之后  可以直接这么写了
        System.out.println(Arrays.toString(names.toArray(size -> new String[size])));
        System.out.println(Arrays.toString(names.toArray(String[]::new)));
    }
1
2
3
4
5
6
7
8

Collection.toArray(IntFunction)
1

在java.util.Collection接口中添加了一个新的默认方法toArray（IntFunction）。此方法允许将集合的元素传输到新创建的所需运行时类型的数组。

     public static void main(String[] args) {
        Set<String> names = Set.of("Fred", "Wilma", "Barney", "Betty");
        //JDK11之前我们只能这么写
        System.out.println(Arrays.toString(names.toArray(new String[names.size()])));
        //JDK11之后  可以直接这么写了
        System.out.println(Arrays.toString(names.toArray(size -> new String[size])));
        System.out.println(Arrays.toString(names.toArray(String[]::new)));
    }
1
2
3
4
5
6
7
8

新方法是现有toArray（T []）方法的重载，该方法将数组实例作为参数。添加重载方法会导致次要源不兼容。以前，形式为coll.toArray（null）的代码将始终解析为现有的toArray方法。使用新的重载方法，此代码现在不明确，将导致编译时错误。 （这只是源不兼容。现有的二进制文件不受影响。）应该更改模糊代码以将null转换为所需的数组类型，例如toArray（（Object []）null）或其他一些数组类型。请注意，将null传递给toArray方法指定为抛出NullPointerException。

4、Stream 加强

Stream 是 Java 8 中的新特性，Java 9 开始对 Stream 增加了以下 4 个新方法。

增加单个参数构造方法，可为null

Stream.ofNullable(null).count(); // 0
//JDK8木有ofNullable方法哦
1
2

源码可看看：

/**
 * @since 9
 */
 public static<T> Stream<T> ofNullable(T t) {
     return t == null ? Stream.empty()
                      : StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
 }
1
2
3
4
5
6
7

增加 takeWhile 和 dropWhile 方法

Stream.of(1, 2, 3, 2, 1)
   .takeWhile(n -> n < 3)
   .collect(Collectors.toList()); // [1, 2]
1
2
3

takeWhile表示从开始计算，当 n < 3 时就截止。

Stream.of(1, 2, 3, 2, 1)
   .dropWhile(n -> n < 3)
   .collect(Collectors.toList()); // [3, 2, 1]
1
2
3

dropWhile这个和上面的相反，一旦 n < 3 不成立就开始计算
3）iterate重载
这个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

    public static void main(String[] args) {
        // 这构造的是无限流  JDK8开始
        Stream.iterate(0, (x) -> x + 1);
        // 这构造的是小于10就结束的流  JDK9开始
        Stream.iterate(0, x -> x < 10, x -> x + 1);
    }
1
2
3
4
5
6

5、Optional 加强

Opthonal 也增加了几个非常酷的方法，现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

Optional.of("javastack")
    .orElseThrow(); // javastack
Optional.of("javastack")
    .stream()
    .count(); // 1
Optional.ofNullable(null)
    .or(() -> Optional.of("javastack"))
    .get(); // javastack
1
2
3
4
5
6
7
8

or方法和stream方法显然都是新增的

6、InputStream 加强

InputStream 终于有了一个非常有用的方法：transferTo，可以用来将数据直接传输到 OutputStream，这是在处理原始数据流时非常常见的一种用法，如下示例。

var classLoader = ClassLoader.getSystemClassLoader();
var inputStream = classLoader.getResourceAsStream("javastack.txt");
var javastack = File.createTempFile("javastack2", "txt");
try (var outputStream = new FileOutputStream(javastack)) {
    inputStream.transferTo(outputStream);
}
1
2
3
4
5
6

7、HTTP Client API(重磅)

在java9及10被标记incubator的模块jdk.incubator.httpclient，在java11被标记为正式，改为java.net.http模块。
这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API，该 API 支持同步和异步，而在 Java 11 中已经为正式可用状态，你可以在 java.net 包中找到这个 API。

来看一下 HTTP Client 的用法：

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://javastack.cn"))
    .GET()
    .build();
var client = HttpClient.newHttpClient();
// 同步
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);
1
2
3
4
5
6
7
8
9
10
11
12

上面的 .GET() 可以省略，默认请求方式为 Get！

更多使用示例可以看这个 API，后续有机会再做演示。

现在 Java 自带了这个 HTTP Client API，我们以后还有必要用 Apache 的 HttpClient 工具包吗？我觉得没啥必要了

8、化繁为简，一个命令编译运行源代码

看下面的代码。

# 编译
javac Javastack.java
# 运行
java Javastack
1
2
3
4

在我们的认知里面，要运行一个 Java 源代码必须先编译，再运行，两步执行动作。而在未来的 Java 11 版本中，通过一个 java 命令就直接搞定了，如以下所示。

java Javastack.java
1

移除项

• 移除了com.sun.awt.AWTUtilities
• 移除了sun.misc.Unsafe.defineClass，使用 java.lang.invoke.MethodHandles.Lookup.defineClass来替代
• 移除了Thread.destroy()以及 Thread.stop(Throwable)方法
  移除了sun.nio.ch.disableSystemWideOverlappingFileLockCheck、sun.locale.formatasdefault属性
• 移除了jdk.snmp模块
• 移除了javafx，openjdk估计是从java10版本就移除了，oracle jdk10还尚未移除javafx，而java11版本则oracle的jdk版本也移除了javafx
• 移除了Java Mission Control，从JDK中移除之后，需要自己单独下载
• 移除了这些Root Certificates ：Baltimore Cybertrust Code Signing CA，SECOM ，AOL and Swisscom

废弃项

• 废弃了Nashorn JavaScript Engine
• 废弃了-XX+AggressiveOpts选项
  -XX:+UnlockCommercialFeatures以及-XX:+LogCommercialFeatures选项也不- 再需要
• 废弃了Pack200工具及其API

说到最后

java11是java改为6个月发布一版的策略之后的第一个LTS(Long-Term Support)版本(oracle版本才有LTS)，这个版本最主要的特性是：在模块方面移除Java EE以及CORBA模块，在JVM方面引入了实验性的ZGC，在API方面正式提供了HttpClient类。

从java11版本开始，不再单独发布JRE或者Server JRE版本了，有需要的可以自己通过jlink去定制runtime image

备注：ZGC作为实验性功能包含在内。要启用它，因此需要将-XX：+ UnlockExperimentalVMOptions选项与-XX：+ UseZGC选项结合使用。
ZGC的这个实验版具有以下限制：

它仅适用于Linux / x64。
不支持使用压缩的oops和/或压缩的类点。默认情况下禁用-XX：+UseCompressedOops和-XX：+UseCompressedClassPointers选项。启用它们将不起作用。
不支持类卸载。默认情况下禁用-XX：+ ClassUnloading和-XX：+ - - ClassUnloadingWithConcurrentMark选项。启用它们将不起作用。
不支持将ZGC与Graal结合使用。

附录：(JAVA 1.0 - JAVA 12的版本时间和代号)