在去年的9月26日，Oracle官方宣布Java11正式釋出，這是Java大版本周期變化後的第一個長期支援版本，非常值得關注。Java9和Java10都在很短的時間内就過渡了，是以，Java11将是一個不可忽視的版本。從時間節點看，JDK11的釋出正好處在JDK8免費更新到期的前夕，同時，JDK8、9也将陸續成為"曆史版本"。
那麼，關于Java11的新特性到底有哪些呢？容我一一介紹。
局部類型推斷
什麼是局部類型推斷？
var str = "helloworld";
System.out.println(str); 複制
局部變量類型推斷就是左邊的類型直接使用var定義，而不用寫具體的類型，編譯器能根據右邊的表達式自動推斷類型，如上面的str變量使用var定義，編譯器就能通過右邊的"helloworld"自動推斷出這是一個String類型的變量。
但是，值得注意的是，這個var并不是一個關鍵字，很多同學看到變量都能使用var來定義，那var還不是關鍵字嗎？事實上，它真的不是一個關鍵字。
int var = 10;
System.out.println(var); 複制
例如上面的這段代碼是能夠正确運作的，這證明var不是關鍵字。
我們還可以通過反編譯來看，例如我們反編譯這樣一段代碼：
var a = 100;
System.out.println(a); 複制
反編譯得到的結果為：
byte a = 100;
System.out.println(a); 複制
從這裡可以看出，var僅僅是一個文法上的改進，在編譯時期便已經将var轉換為了對應的變量類型。
然而在使用var定義變量時，必須立刻指派，例如下面的情況是錯誤的：
var a; 複制
因為在不指派的情況下，JVM無法推斷目前變量的類型。
在類中的成員變量(也叫屬性)不可以使用var來定義，例如下面的情況是錯誤的：
class Student{
var name = "小明";
var age = 20;
} 複制
var的好處在lambda表達式中展現得淋漓盡緻。我們知道，開啟一個線程可以使用lambda表達式來完成：
Thread t = new Thread(() -> System.out.println(Thread.currentThread().getName()));
t.start(); 複制
這是一個無參的lambda表達式形式，我們再看一個帶參lambda表達式：
String[] arr = { "program", "creek", "is", "a", "java", "site" };
Stream<String> stream = Stream.of(arr);
stream.forEach(x -> System.out.print(x + "\t")); 複制
這是一個forEach的用法，其中需要用到變量x，因為這裡它自動推斷出了x的類型為String，是以String被省略了，那麼加上var之後代碼變成這樣：
String[] arr = { "program", "creek", "is", "a", "java", "site" };
Stream<String> stream = Stream.of(arr);
stream.forEach((var x) -> System.out.print(x + "\t")); 複制
如果僅僅隻是這樣寫，倒是無法看出寫var有什麼優勢，反而覺得有點多此一舉，但是如果要給lambda表達式變量标注注解的話，那麼這個時候var的作用就展現出來了。
String[] arr = { "program", "creek", "is", "a", "java", "site" };
Stream<String> stream = Stream.of(arr);
stream.forEach((@Nonnull var x) -> System.out.print(x + "\t")); 複制
那麼var的優勢何在呢？因為你要标注注解的話，就必定要寫出x的類型，如下面這段程式是錯誤的：
String[] arr = { "program", "creek", "is", "a", "java", "site" };
Stream<String> stream = Stream.of(arr);
stream.forEach((@Nonnull x) -> System.out.print(x + "\t")); 複制
但是，我們從何得知x的類型呢？其實我們不用知曉，因為var就能自動推斷，是以，var的好處在這裡就展現出來了。
集合中的新API
在Java9之前，我們要想建立新集合，我們得這樣做：
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java"); 複制
建立過程略顯麻煩，那麼現在，我們可以通過這樣的方式來建立集合：
List<String> list = List.of("hello","world","java"); 複制
但是，請注意了，用這樣的方式來建立的集合，是無法添加元素的，我們可以嘗試着添加一下：
List<String> list = List.of("hello","world","java");
list.add("test"); 複制
運作結果如下：
Exception in thread "main" java.lang.UnsupportedOperationException
at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:71)
at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.add(ImmutableCollections.java:75)
at com.itcast.TestDemo.main(TestDemo.java:8) 複制
那麼這到底是為什麼呢？我們通過源碼來分析一下。
首先我麼看看List類的of()方法：
static <E> List<E> of(E e1, E e2, E e3) {
return new ImmutableCollections.ListN<>(e1, e2, e3);
} 複制
該方法調用了ImmutableCollections類的ListN()生成一個集合并傳回，我們看看ListN的源碼：
static final class ListN<E> extends AbstractImmutableList<E>
implements Serializable {
static final List<?> EMPTY_LIST = new ListN<>();
@Stable
private final E[] elements;
@SafeVarargs
ListN(E... input) {
// copy and check manually to avoid TOCTOU
@SuppressWarnings("unchecked")
E[] tmp = (E[])new Object[input.length]; // implicit nullcheck of input
for (int i = 0; i < input.length; i++) {
tmp[i] = Objects.requireNonNull(input[i]);
}
elements = tmp;
}
@Override
public boolean isEmpty() {
return size() == 0;
}
@Override
public int size() {
return elements.length;
}
@Override
public E get(int index) {
return elements[index];
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_LIST, elements);
}
} 複制
它是ImmutableCollections類的一個靜态内部類，我們暫且不管它是如何生成集合的，我們找找裡面有沒有add()方法，會發現裡面并不存在add()方法，那麼我們既然能夠調用到，那麼add()方法肯定在其父類中。最終，在它的父類AbstractImmutableCollection中找到了add()方法：
// all mutating methods throw UnsupportedOperationException
@Override public boolean add(E e) { throw uoe(); }
@Override public boolean addAll(Collection<? extends E> c) { throw uoe(); }
@Override public void clear() { throw uoe(); }
@Override public boolean remove(Object o) { throw uoe(); }
@Override public boolean removeAll(Collection<?> c) { throw uoe(); }
@Override public boolean removeIf(Predicate<? super E> filter) { throw uoe(); }
@Override public boolean retainAll(Collection<?> c) { throw uoe(); } 複制
add()方法調用了uoe()方法，而uoe()方法直接抛出了一個異常：
static UnsupportedOperationException uoe() { return new UnsupportedOperationException(); } 複制
會發現，調用uoe()方法的不隻add()方法一個，有關于集合添加、修改、删除的種種操作都會抛出異常。是以，由of()方法建立的集合是不可以進行這些相關操作的。
流中的新API
上面集合中說到的of()方法同樣可以用在流中。
Stream<Integer> stream = Stream.of(1,2,3,4,5); 複制
Stream stream = Stream.of();
Stream stream2 = Stream.of(null); 複制
而在上面的兩條語句中，第二條語句會産生空指針異常，當然，我們不能允許我們的程式出現這樣的異常，但是你又很有可能會傳入一個null，這樣的情況該如何避免呢？從Java9開始，出現了一個新方法：
Stream stream3 = Stream.ofNullable(null); 複制
該方法允許你傳入一個null值，以此避免空指針異常産生。
繼續介紹Stream中的新API。
-
takeWhile()
該方法會從流中一直擷取判定器為真的元素，一旦遇到元素為假，就終止處理
Stream<Integer> stream = Stream.of(1, 3, 2, 5, 6, 7);
Stream stream2 = stream.takeWhile(t -> t % 2 != 0);
stream2.forEach(System.out::println); 複制
這段程式的運作結果：
1
3 複制
你若是了解了這個方法的意思，這樣的輸出結果就不難了解。因為當擷取到元素2時，判定器為假，此時會終止處理，是以後面的元素就不會再去處理。
2.dropWhile()
那麼這方法和takeWhile()方法相反，它會從流中一直丢棄判定器為真的元素，一旦遇到元素為假，就終止處理
Stream<Integer> stream = Stream.of(1, 3, 2, 5, 6, 7);
Stream stream2 = stream.dropWhile(t -> t % 2 != 0);
stream2.forEach(System.out::println); 複制
是以上面程式段的執行結果為：
2
5
6
7 複制
字元串中的新API
1.isBlank()
判斷字元串中的字元是否都為空白
2.strip()
去除字元串首尾的空白
3.stripTrailing()
去除字元串尾部的空白
4.stripLeading()
去除字元串首部的空白
5.repeat()
複制字元串，可以傳入一個int類型值來控制複制次數
我們知道在字元串處理方法中，trim()方法也能夠去除字元串首尾的空白，那為什麼Oracle還要設計一個重複的方法呢？這必然有它的道理。其實，trim()方法要比strip()方法簡單得多：
/**
* Returns a string whose value is this string, with all leading
* and trailing space removed, where space is defined
* as any character whose codepoint is less than or equal to
* {@code 'U+0020'} (the space character).
*/
public String trim() {
String ret = isLatin1() ? StringLatin1.trim(value)
: StringUTF16.trim(value);
return ret == null ? this : ret;
} 複制
通過查閱源碼中對該方法的注釋發現，trim()方法隻能去除Unicode碼值小于等于32的空白字元，而32正好指的是空格，那麼對于全角的空格，trim()方法就無能為力了。是以在功能上，strip()方法更加強大。
HttpAPI
這是Java9開始引入的一個處理HTTP請求的API，該API支援同步和異步，而在Java11中已經為正式可用狀态。
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder(URI.create("http://www.baidu.com")).build();
BodyHandler<String> responseBodyHandler = BodyHandlers.ofString();
HttpResponse<String> response = client.send(request, responseBodyHandler);
String body = response.body();
System.out.println(body); 複制
這是一段基本的通路百度的請求代碼，當然，它還提供了異步請求方式：
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder(URI.create("http://www.baidu.com")).build();
BodyHandler<String> responseBodyHandler = BodyHandlers.ofString();
CompletableFuture<HttpResponse<String>> sendAsync = client.sendAsync(request, responseBodyHandler);
HttpResponse<String> response = sendAsync.get();
String body = response.body();
System.out.println(body); 複制
新版本廢棄了哪些内容
- 删除了com.sun.awt.AWTUtilities類
-
從Oracle JDK中删除了Lucida字型
Oracle JDK不再提供任何字型，完全依賴于作業系統上安裝的字型。
- 删除了appletviewer啟動器
Epsilon垃圾收集器
JDK上對這個特性的描述是：開發一個處理記憶體配置設定但不實作任何實際記憶體回收機制的GC，一旦可用堆記憶體用完，JVM就會退出。
我們可以來嘗試着使用一下它，首先我們編寫一段程式：
public class EpsilonTest {
public static void main(String[] args) throws Exception {
var list = new ArrayList<>();
boolean flag = true;
int count = 0;
while (flag) {
list.add(new Garbage());
if (count++ == 500) {
list.clear();
}
}
}
}
class Garbage {
private double d1 = 1;
private double d2 = 2;
/**
* GC在清除本對象時會調用該方法
*/
@Override
protected void finalize() throws Throwable {
System.out.println(this + " collecting");
}
} 複制
這是一個無限循環的程式，循環體不斷建立Garbage對象并放入集合，當循環次數達到500時将集合清空，此時的500個對象均為垃圾，會被GC清理，清理時調用finalize()方法列印資訊。運作這段程式，結果如下：
...
com.itcast.Garbage@1e9c634c collecting
java.lang.OutOfMemoryError: Java heap space
at com.itcast.EpsilonTest.main(EpsilonTest.java:11)
com.itcast.Garbage@1174213e collecting
com.itcast.Garbage@2029a4b8 collecting
... 複制
當程式執行到某一刻時，記憶體溢出，程式終止。
現在我們來使用一下Epsilon，右鍵選擇類檔案，在Run As右側選擇Run Configurations：
現在我們将預設的GC換為了Epsilon，再來看看運作結果：
Terminating due to java.lang.OutOfMemoryError: Java heap space 複制
會發現，控制台隻輸出了這麼一句，說明被清除的集合中的對象并沒有被回收，而且記憶體溢出的速度也非常快，這說明該GC是并不會回收垃圾，那麼它有什麼作用呢？
它提供完全被動的GC實作，具有有限的配置設定限制和盡可能低的延遲開銷，但代價是記憶體占用和記憶體吞吐量，它的主要用途有以下幾個方面：
- 性能測試(它可以幫助過濾掉GC引起的性能假象)
- 記憶體壓力測試
- 非常短的JOB任務
- VM接口測試
ZGC垃圾回收器
有人說這是JDK11最為矚目的特性，沒有之一，是最重磅的更新，那麼ZGC的優勢在哪裡呢？
- GC暫停時間不會超過10毫秒
- 既能處理幾百兆的小堆，也能處理幾個T的大堆
- 和G1相比，應用吞吐能力不會下降超過15%
- 為未來的GC功能和利用colord指針以及Load barriers優化奠定了基礎
ZGC是一個并發、基于region、壓縮型的垃圾收集器，隻有root掃描階段會STW(stop the world，停止所有線程)，是以ZGC的停頓時間不會随着堆的增長和存活對象的增長而變長。
用法：-XX:UnlockExperimentalVMOptions -XX:+UseZGC
雖然功能如此強大，但很遺憾的是，在Windows系統的JDK中并沒有提供ZGC，是以也就沒有辦法嘗鮮了。
Flight Recorder
這是一個記錄儀，用于診斷程式運作過程，那麼在之前這是一個商業版的特性，是要收費的，從Java11開始，Fight Recorder免費提供使用并開源。它可以導出事件到檔案中，之後可以用Java Mission Control來分析，也可以在應用啟動時配置java -XX:StartFlightRecording或者在應用啟動之後使用jcmd來錄制，比如：
$ jcmd <pid> JFR.start
$ jcmd <pid> JFR.dump filename=
$ jcmd <pid> JFR.stop 複制
其它
在Java11中，支援一個指令編譯運作檔案，在之前的版本中，我們要想運作一個Java程式，首先得用javac指令編譯，然後用java指令運作。而在新版本中，我們直接使用java指令即可完成編譯運作操作。
在Unicode10版本中，增加了8518個字元，總計達到了136690個字元，這已經超出了char類型的數值範圍，是以在Java11中，新增了CharacterData，使用四個位元組來處理字元。
那麼有關Java11的新特性就介紹到這裡。