Java5

Java5開發代號為Tiger(老虎),於2004-09-30發行

特性列表

• 泛型
• 列舉
• 自動裝箱拆箱
• 可變引數
• 註解
• foreach迴圈（增強for、for/in）
• 靜態匯入
• 格式化（System.out.println 支援%s %d等格式化輸出）
• 執行緒框架/資料結構 JUC
• Arrays工具類/StringBuilder/instrument

 

1、泛型

所謂型別擦除指的就是Java原始碼中的範型資訊只允許停留在編譯前期，而編譯後的位元組碼檔案中將不再保留任何的範型資訊。也就是說，範型資訊在編譯時將會被全部刪除，其中範型型別的型別引數則會被替換為Object型別，並在實際使用時強制轉換為指定的目標資料型別。而C++中的模板則會在編譯時將模板型別中的型別引數根據所傳遞的指定資料型別生成相對應的目的碼。

Map<Integer, Integer> squares = new HashMap<Integer, Integer>();

 

萬用字元型別：避免unchecked警告，問號表示任何型別都可以接受

public void printList(List<?> list, PrintStream out) throws IOException {
     for (Iterator<?> i = list.iterator(); i.hasNext(); ) {
         out.println(i.next().toString());
     }
 }
 

 

限制類型

public static <A extends Number> double sum(Box<A> box1,Box<A> box2){
     double total = 0;
     for (Iterator<A> i = box1.contents.iterator(); i.hasNext(); ) {
         total = total + i.next().doubleValue();
     }
     for (Iterator<A> i = box2.contents.iterator(); i.hasNext(); ) {
         total = total + i.next().doubleValue();
     }
     return total;
 }
 

2、列舉

EnumMap

public void testEnumMap(PrintStream out) throws IOException {
     // Create a map with the key and a String message
     EnumMap<AntStatus, String> antMessages =
         new EnumMap<AntStatus, String>(AntStatus.class);
     // Initialize the map
     antMessages.put(AntStatus.INITIALIZING, "Initializing Ant...");
     antMessages.put(AntStatus.COMPILING, "Compiling Java classes...");
     antMessages.put(AntStatus.COPYING, "Copying files...");
     antMessages.put(AntStatus.JARRING, "JARring up files...");
     antMessages.put(AntStatus.ZIPPING, "ZIPping up files...");
     antMessages.put(AntStatus.DONE, "Build complete.");
     antMessages.put(AntStatus.ERROR, "Error occurred.");
     // Iterate and print messages
     for (AntStatus status : AntStatus.values() ) {
         out.println("For status " + status + ", message is: " +
         antMessages.get(status));
     }
 }

 

switch列舉

public String getDescription() {
     switch(this) {
         case ROSEWOOD: return "Rosewood back and sides";
         case MAHOGANY: return "Mahogany back and sides";
         case ZIRICOTE: return "Ziricote back and sides";
         case SPRUCE: return "Sitka Spruce top";
         case CEDAR: return "Wester Red Cedar top";
         case AB_ROSETTE: return "Abalone rosette";
         case AB_TOP_BORDER: return "Abalone top border";
         case IL_DIAMONDS: 
             return "Diamonds and squares fretboard inlay";
         case IL_DOTS:
             return "Small dots fretboard inlay";
         default: return "Unknown feature";
     }
 }

3、自動拆箱/裝箱

將primitive型別轉換成對應的wrapper型別：Boolean、Byte、Short、Character、Integer、Long、Float、Double

 

4、可變引數

private String print(Object... values) {
     StringBuilder sb = new StringBuilder();
     for (Object o : values) {
         sb.append(o.toString())
         .append(" ");
     }
     return sb.toString();
 }

 

5、註解

Inherited表示該註解是否對類的子類繼承的方法等起作用

@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface InProgress { }

 

Target型別

Rentation表示annotation是否保留在編譯過的class檔案中還是在執行時可讀。

 

6、增強for迴圈 for/in

for/in迴圈辦不到的事情：

（1）遍歷同時獲取index

（2）集合逗號拼接時去掉最後一個

（3）遍歷的同時刪除元素

 

7、靜態匯入

import static java.lang.System.err;
import static java.lang.System.out;
err.println(msg); 

 

8、print輸出格式化

System.out.println("Line %d: %s%n", i++, line);

 

9、併發支援（JUC）

 

執行緒池

uncaught exception（可以抓住多執行緒內的異常）

class SimpleThreadExceptionHandler implements Thread.UncaughtExceptionHandler {
     public void uncaughtException(Thread t, Throwable e) {
         System.err.printf("%s: %s at line %d of %s%n",
         t.getName(), 
         e.toString(),
         e.getStackTrace()[0].getLineNumber(),
         e.getStackTrace()[0].getFileName());
     }
}

 

blocking queue(BlockingQueue)

JUC類庫

 

10、Arrays、Queue、執行緒安全StringBuilder

Arrays工具類

Arrays.sort(myArray);
Arrays.toString(myArray)
Arrays.binarySearch(myArray, 98)
Arrays.deepToString(ticTacToe)
Arrays.deepEquals(ticTacToe, ticTacToe3)

 

Queue

避開集合的add/remove操作，使用offer、poll操作（不拋異常）

Queue介面與List、Set同一級別，都是繼承了Collection介面。LinkedList實現了Deque介面。

Queue q = new LinkedList(); //採用它來實現queue

 

Override返回型別

單執行緒StringBuilder

java.lang.instrument

 

Java 6

Java6開發代號為Mustang(野馬),於2006-12-11發行。評價：雞肋的版本，有JDBC4.0更新、Complier API、WebSevice支援的加強等更新。

1、Web Services

優先支援編寫 XML web service 客戶端程式。你可以用過簡單的annotaion將你的API釋出成.NET互動的web services. Mustang 添加了新的解析和 XML 在 Java object-mapping APIs中, 之前只在Java EE平臺實現或者Java Web Services Pack中提供.

2、Scripting（開啟JS的支援，算是比較有用的）

現在你可以在Java原始碼中混入JavaScript了，這對開發原型很有有用，你也可以插入自己的指令碼引擎。

3、Database

Mustang 將聯合繫結 Java DB (Apache Derby). JDBC 4.0 增加了許多特性例如支援XML作為SQL資料型別，更好的整合Binary Large OBjects (BLOBs) 和 Character Large OBjects (CLOBs) .

4、More Desktop APIs

GUI 開發者可以有更多的技巧來使用 SwingWorker utility ，以幫助GUI應用中的多執行緒。, JTable 分類和過濾，以及新增splash閃屏。

很顯然，這對於主攻伺服器開發的Java來說，並沒有太多吸引力

5、Monitoring and Management.

綁定了不是很知名的 memory-heap 分析工具Jhat 來檢視核心匯出。

6、Compiler Access（這個很厲害）

compiler API提供程式設計訪問javac，可以實現程序內編譯，動態產生Java程式碼。

7、Pluggable Annotation

8、Desktop Deployment.

Swing擁有更好的 look-and-feel , LCD 文字呈現, 整體GUI效能的提升。Java應用程式可以和本地平臺更好的整合，例如訪問平臺的系統托盤和開始選單。Mustang將Java外掛技術和Java Web Start引擎統一了起來。

9、Security

XML-數字簽名(XML-DSIG) APIs 用於建立和操縱數字簽名); 新的方法來訪問本地平臺的安全服務

10、The -ilities（很好的習慣）

質量，相容性，穩定性。 80,000 test cases 和數百萬行測試程式碼(只是測試活動中的一個方面). Mustang 的快照發布已經被下載15個月了，每一步中的Bug都被修復了，表現比J2SE 5還要好。

 

Java 7

特性列表

• switch中新增對String型別的支援
• 數字字面量的改進 / 數值可加下劃
• 異常處理（捕獲多個異常） try-with-resources
• 增強泛型推斷
• JSR203 NIO2.0（AIO）新IO的支援
• JSR292與InvokeDynamic指令
• Path介面、DirectoryStream、Files、WatchService（重要介面更新）
• fork/join framework

1、switch中新增對String型別的支援

 String title = ""; 
 switch (gender) { 
     case "男": 
         title = name + " 先生"; 
         break; 
     case "女": 
         title = name + " 女士"; 
         break; 
     default: 
         title = name; 
} 
return title; 

 

編譯器在編譯時先做處理：

①case僅僅有一種情況。直接轉成if。

②假設僅僅有一個case和default，則直接轉換為if…else…。

③有多個case。先將String轉換為hashCode，然後相應的進行處理，JavaCode在底層相容Java7曾經版本號。

2、數字字面量的改進

Java7前支援十進位制（123）、八進位制（0123）、十六進位制（0X12AB）

Java7新增二進位制表示（0B11110001、0b11110001）

數字中可加入分隔符

Java7中支援在數字量中間新增’_'作為分隔符。更直觀，如（12_123_456）。下劃線僅僅能在數字中間。編譯時編譯器自己主動刪除數字中的下劃線。

int one_million = 1_000_000;

3、異常處理（捕獲多個異常） try-with-resources

catch子句能夠同一時候捕獲多個異常

public void testSequence() { 
     try { 
         Integer.parseInt("Hello"); 
     } 
     catch (NumberFormatException | RuntimeException e) { //使用'|'切割，多個型別，一個物件e 
     } 
 } 

 

try-with-resources語句

Java7之前須要在finally中關閉socket、檔案、資料庫連線等資源；

Java7中在try語句中申請資源，實現資源的自己主動釋放（資源類必須實現java.lang.AutoCloseable介面，一般的檔案、資料庫連線等均已實現該介面，close方法將被自己主動呼叫）。

public void read(String filename) throws IOException { 
     try (BufferedReader reader = new BufferedReader(new FileReader(filename))) { 
     StringBuilder builder = new StringBuilder(); 
     String line = null; 
     while((line=reader.readLine())!=null){ 
         builder.append(line); 
         builder.append(String.format("%n")); 
     } 
     return builder.toString(); 
     } 
 } 

4、增強泛型推斷

Map<String, List<String>> map = new HashMap<String, List<String>>(); 

 

Java7之後可以簡單的這麼寫

Map<String, List<String>> anagrams = new HashMap<>(); 

5、NIO2.0（AIO）新IO的支援

bytebuffer

public class ByteBufferUsage {
	 public void useByteBuffer() {
		 ByteBuffer buffer = ByteBuffer.allocate(32);
		 buffer.put((byte)1);
		 buffer.put(new byte[3]);
		 buffer.putChar('A');
		 buffer.putFloat(0.0f);
		 buffer.putLong(10, 100L);
		 System.out.println(buffer.getChar(4));
		 System.out.println(buffer.remaining());
	 }
	 public void byteOrder() {
		 ByteBuffer buffer = ByteBuffer.allocate(4);
		 buffer.putInt(1);
		 buffer.order(ByteOrder.LITTLE_ENDIAN);
		 buffer.getInt(0); //值為16777216
	 }
	 public void compact() {
		 ByteBuffer buffer = ByteBuffer.allocate(32);
		 buffer.put(new byte[16]);
		 buffer.flip();
		 buffer.getInt();
		 buffer.compact();
		 int pos = buffer.position();
	 }
	 public void viewBuffer() {
		 ByteBuffer buffer = ByteBuffer.allocate(32);
		 buffer.putInt(1);
		 IntBuffer intBuffer = buffer.asIntBuffer();
		 intBuffer.put(2);
		 int value = buffer.getInt(); //值為2
	 }
	 /**
	 * @param args the command line arguments
	 */
	 public static void main(String[] args) {
		 ByteBufferUsage bbu = new ByteBufferUsage();
		 bbu.useByteBuffer();
		 bbu.byteOrder();
		 bbu.compact();
		 bbu.viewBuffer();
	 }
}

 

filechannel

public class FileChannelUsage {
	 public void openAndWrite() throws IOException {
		 FileChannel channel = FileChannel.open(Paths.get("my.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
		 ByteBuffer buffer = ByteBuffer.allocate(64);
		 buffer.putChar('A').flip();
		 channel.write(buffer);
	 }
	 public void readWriteAbsolute() throws IOException {
		 FileChannel channel = FileChannel.open(Paths.get("absolute.txt"), StandardOpenOption.READ, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
		 ByteBuffer writeBuffer = ByteBuffer.allocate(4).putChar('A').putChar('B');
		 writeBuffer.flip();
		 channel.write(writeBuffer, 1024);
		 ByteBuffer readBuffer = ByteBuffer.allocate(2);
		 channel.read(readBuffer, 1026);
		 readBuffer.flip();
		 char result = readBuffer.getChar(); //值為'B'
	 }
	 /**
	 * @param args the command line arguments
	 */
	 public static void main(String[] args) throws IOException {
		 FileChannelUsage fcu = new FileChannelUsage();
		 fcu.openAndWrite();
		 fcu.readWriteAbsolute();
	 }
}

6、JSR292與InvokeDynamic

 

JSR 292: Supporting Dynamically Typed Languages on the JavaTM Platform，支援在JVM上執行動態型別語言。在位元組碼層面支援了InvokeDynamic。

public class ThreadPoolManager {
 private final ScheduledExecutorService stpe = Executors
 .newScheduledThreadPool(2);
 private final BlockingQueue<WorkUnit<String>> lbq;
 public ThreadPoolManager(BlockingQueue<WorkUnit<String>> lbq_) {
 lbq = lbq_;
 }
 public ScheduledFuture<?> run(QueueReaderTask msgReader) {
 msgReader.setQueue(lbq);
 return stpe.scheduleAtFixedRate(msgReader, 10, 10, TimeUnit.MILLISECONDS);
 }
 private void cancel(final ScheduledFuture<?> hndl) {
 stpe.schedule(new Runnable() {
 public void run() {
 hndl.cancel(true);
 }
 }, 10, TimeUnit.MILLISECONDS);
 }
 /**
 * 使用傳統的反射api
 */
 public Method makeReflective() {
 Method meth = null;
 try {
 Class<?>[] argTypes = new Class[]{ScheduledFuture.class};
 meth = ThreadPoolManager.class.getDeclaredMethod("cancel", argTypes);
 meth.setAccessible(true);
 } catch (IllegalArgumentException | NoSuchMethodException
 | SecurityException e) {
 e.printStackTrace();
 }
 return meth;
 }
 /**
 * 使用代理類
 * @return
 */
 public CancelProxy makeProxy() {
 return new CancelProxy();
 }
 /**
 * 使用Java7的新api，MethodHandle
 * invoke virtual 動態繫結後呼叫 obj.xxx
 * invoke special 靜態繫結後呼叫 super.xxx
 * @return
 */
 public MethodHandle makeMh() {
 MethodHandle mh;
 MethodType desc = MethodType.methodType(void.class, ScheduledFuture.class);
 try {
 mh = MethodHandles.lookup().findVirtual(ThreadPoolManager.class,
 "cancel", desc);
 } catch (NoSuchMethodException | IllegalAccessException e) {
 throw (AssertionError) new AssertionError().initCause(e);
 }
 return mh;
 }
 public static class CancelProxy {
 private CancelProxy() {
 }
 public void invoke(ThreadPoolManager mae_, ScheduledFuture<?> hndl_) {
 mae_.cancel(hndl_);
 }
 }
}

 

呼叫invoke

public class ThreadPoolMain {
 /**
 * 如果被繼承，還能在靜態上下文尋找正確的class
 */
 private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 private ThreadPoolManager manager;
 public static void main(String[] args) {
 ThreadPoolMain main = new ThreadPoolMain();
 main.run();
 }
 private void cancelUsingReflection(ScheduledFuture<?> hndl) {
 Method meth = manager.makeReflective();
 try {
 System.out.println("With Reflection");
 meth.invoke(hndl);
 } catch (IllegalAccessException | IllegalArgumentException
 | InvocationTargetException e) {
 e.printStackTrace();
 }
 }
 private void cancelUsingProxy(ScheduledFuture<?> hndl) {
 CancelProxy proxy = manager.makeProxy();
 System.out.println("With Proxy");
 proxy.invoke(manager, hndl);
 }
 private void cancelUsingMH(ScheduledFuture<?> hndl) {
 MethodHandle mh = manager.makeMh();
 try {
 System.out.println("With Method Handle");
 mh.invokeExact(manager, hndl);
 } catch (Throwable e) {
 e.printStackTrace();
 }
 }
 private void run() {
 BlockingQueue<WorkUnit<String>> lbq = new LinkedBlockingQueue<>();
 manager = new ThreadPoolManager(lbq);
 final QueueReaderTask msgReader = new QueueReaderTask(100) {
 @Override
 public void doAction(String msg_) {
 if (msg_ != null)
 System.out.println("Msg recvd: " + msg_);
 }
 };
 ScheduledFuture<?> hndl = manager.run(msgReader);
 cancelUsingMH(hndl);
 // cancelUsingProxy(hndl);
 // cancelUsingReflection(hndl);
 }
}

7、Path介面(重要介面更新)

Path

public class PathUsage {
 public void usePath() {
 Path path1 = Paths.get("folder1", "sub1");
 Path path2 = Paths.get("folder2", "sub2");
 path1.resolve(path2); //folder1sub1older2sub2
 path1.resolveSibling(path2); //folder1older2sub2
 path1.relativize(path2); //....older2sub2
 path1.subpath(0, 1); //folder1
 path1.startsWith(path2); //false
 path1.endsWith(path2); //false
 Paths.get("folder1/./../folder2/my.text").normalize(); //folder2my.text
 }
 /**
 * @param args the command line arguments
 */
 public static void main(String[] args) {
 PathUsage usage = new PathUsage();
 usage.usePath();
 }
}

 

DirectoryStream

public class ListFile {
 public void listFiles() throws IOException {
 Path path = Paths.get("");
 try (DirectoryStream<Path> stream = Files.newDirectoryStream(path, "*.*")) {
 for (Path entry: stream) {
 //使用entry
 System.out.println(entry);
 }
 }
 }
 /**
 * @param args the command line arguments
 */
 public static void main(String[] args) throws IOException {
 ListFile listFile = new ListFile();
 listFile.listFiles();
 }
}

Files

public class FilesUtils {
 public void manipulateFiles() throws IOException {
 Path newFile = Files.createFile(Paths.get("new.txt").toAbsolutePath());
 List<String> content = new ArrayList<String>();
 content.add("Hello");
 content.add("World");
 Files.write(newFile, content, Charset.forName("UTF-8"));
 Files.size(newFile);
 byte[] bytes = Files.readAllBytes(newFile);
 ByteArrayOutputStream output = new ByteArrayOutputStream();
 Files.copy(newFile, output);
 Files.delete(newFile);
 }
 /**
 * @param args the command line arguments
 */
 public static void main(String[] args) throws IOException {
 FilesUtils fu = new FilesUtils();
 fu.manipulateFiles();
 }
}

WatchService

public class WatchAndCalculate {
 public void calculate() throws IOException, InterruptedException {
 WatchService service = FileSystems.getDefault().newWatchService();
 Path path = Paths.get("").toAbsolutePath();
 path.register(service, StandardWatchEventKinds.ENTRY_CREATE);
 while (true) {
 WatchKey key = service.take();
 for (WatchEvent<?> event : key.pollEvents()) {
 Path createdPath = (Path) event.context();
 createdPath = path.resolve(createdPath);
 long size = Files.size(createdPath);
 System.out.println(createdPath + " ==> " + size);
 }
 key.reset();
 }
 }
 /**
 * @param args the command line arguments
 */
 public static void main(String[] args) throws Throwable {
 WatchAndCalculate wc = new WatchAndCalculate();
 wc.calculate();
 }
}

8、fork/join計算框架

Java7提供的一個用於並行執行任務的框架，是一個把大任務分割成若干個小任務，最終彙總每個小任務結果後得到大任務結果的框架。

該框架為Java8的並行流打下了堅實的基礎

 

Java 8

Java 8可謂是自Java 5以來最具革命性的版本了，她在語言、編譯器、類庫、開發工具以及Java虛擬機器等方面都帶來了不少新特性。

 

一、Lambda表示式

Lambda表示式可以說是Java 8最大的賣點，她將函數語言程式設計引入了Java。Lambda允許把函式作為一個方法的引數，或者把程式碼看成資料。

一個Lambda表示式可以由用逗號分隔的引數列表、–>符號與函式體三部分表示。例如：

Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e -> System.out.println( e ) );

為了使現有函式更好的支援Lambda表示式，Java 8引入了函式式介面的概念。函式式介面就是隻有一個方法的普通介面。java.lang.Runnable與java.util.concurrent.Callable是函式式介面最典型的例子。為此，Java 8增加了一種特殊的註解@FunctionalInterface

 

二、介面的預設方法與靜態方法

我們可以在介面中定義預設方法，使用default關鍵字，並提供預設的實現。所有實現這個介面的類都會接受預設方法的實現，除非子類提供的自己的實現。例如：

public interface DefaultFunctionInterface {
 default String defaultFunction() {
 return "default function";
 }
 }

 

我們還可以在介面中定義靜態方法，使用static關鍵字，也可以提供實現。例如：

public interface StaticFunctionInterface {
 static String staticFunction() {
 return "static function";
 }
 }

介面的預設方法和靜態方法的引入，其實可以認為引入了C＋＋中抽象類的理念，以後我們再也不用在每個實現類中都寫重複的程式碼了。

 

三、方法引用（含構造方法引用）

通常與Lambda表示式聯合使用，可以直接引用已有Java類或物件的方法。一般有四種不同的方法引用：

構造器引用。語法是Class::new，或者更一般的Class< T >::new，要求構造器方法是沒有引數；

靜態方法引用。語法是Class::static_method，要求接受一個Class型別的引數；

特定類的任意物件方法引用。它的語法是Class::method。要求方法是沒有引數的；

特定物件的方法引用，它的語法是instance::method。要求方法接受一個引數，與3不同的地方在於，3是在列表元素上分別呼叫方法，而4是在某個物件上呼叫方法，將列表元素作為引數傳入；

 

四、重複註解

在Java 5中使用註解有一個限制，即相同的註解在同一位置只能宣告一次。Java 8引入重複註解，這樣相同的註解在同一地方也可以宣告多次。重複註解機制本身需要用@Repeatable註解。Java 8在編譯器層做了優化，相同註解會以集合的方式儲存，因此底層的原理並沒有變化。

 

五、擴充套件註解的支援（型別註解）

Java 8擴充套件了註解的上下文，幾乎可以為任何東西添加註解，包括區域性變數、泛型類、父類與介面的實現，連方法的異常也能添加註解。

private @NotNull String name;

 

六、Optional

Java 8引入Optional類來防止空指標異常，Optional類最先是由Google的Guava專案引入的。Optional類實際上是個容器：它可以儲存型別T的值，或者儲存null。使用Optional類我們就不用顯式進行空指標檢查了。

 

七、Stream

Stream API是把真正的函數語言程式設計風格引入到Java中。其實簡單來說可以把Stream理解為MapReduce，當然Google的MapReduce的靈感也是來自函數語言程式設計。她其實是一連串支援連續、並行聚集操作的元素。從語法上看，也很像linux的管道、或者鏈式程式設計，程式碼寫起來簡潔明瞭，非常酷帥！

 

八、Date/Time API (JSR 310)

Java 8新的Date-Time API (JSR 310)受Joda-Time的影響，提供了新的java.time包，可以用來替代 java.util.Date和java.util.Calendar。一般會用到Clock、LocaleDate、LocalTime、LocaleDateTime、ZonedDateTime、Duration這些類，對於時間日期的改進還是非常不錯的。

 

九、JavaScript引擎Nashorn

Nashorn允許在JVM上開發執行JavaScript應用，允許Java與JavaScript相互呼叫。

 

十、Base64

在Java 8中，Base64編碼成為了Java類庫的標準。Base64類同時還提供了對URL、MIME友好的編碼器與解碼器。

說在後面

除了這十大特性，還有另外的一些新特性：

更好的型別推測機制：Java 8在型別推測方面有了很大的提高，這就使程式碼更整潔，不需要太多的強制型別轉換了。

編譯器優化：Java 8將方法的引數名加入了位元組碼中，這樣在執行時通過反射就能獲取到引數名，只需要在編譯時使用-parameters引數。

並行（parallel）陣列：支援對陣列進行並行處理，主要是parallelSort()方法，它可以在多核機器上極大提高陣列排序的速度。

併發（Concurrency）：在新增Stream機制與Lambda的基礎之上，加入了一些新方法來支援聚集操作。

Nashorn引擎jjs：基於Nashorn引擎的命令列工具。它接受一些JavaScript原始碼為引數，並且執行這些原始碼。

類依賴分析器jdeps：可以顯示Java類的包級別或類級別的依賴。

JVM的PermGen空間被移除：取代它的是Metaspace（JEP 122）。

 

Java 9

經過4次跳票，歷經曲折的java 9 終於終於在2017年9月21日釋出（距離上個版本足足3年半時間）java 9 提供了超過 150 項新功能特性，包括備受期待的模組化系統、可互動的 REPL 工具：jshell，JDK 編譯工具，Java 公共 API 和私有程式碼，以及安全增強、擴充套件提升、效能管理改善等。可以說 Java 9 是一個龐大的系統工程，完全做了一個整體改變。但本博文只介紹最重要的十大新特性

特性列表

• 平臺級modularity（原名：Jigsaw） 模組化系統
• Java 的 REPL 工具： jShell 命令
• 多版本相容 jar 包（這個在處理向下相容方面，非常好用）
• 語法改進：介面的私有方法
• 語法改進：UnderScore(下劃線)使用的限制
• 底層結構：String 儲存結構變更（這個很重要）
• 集合工廠方法：快速建立只讀集合
• 增強的 Stream API
• 全新的 HTTP 客戶端 API
• 其它特性
• 它的新特性來自於100於項JEP和40於項JSR

 

Java 10

2018年3月20日，Java 10 正式釋出，這一次沒有跳票。它號稱有109項新特性，包含12個JEP。需要注意的是，本次Java10並不是Oracle的官方LTS版本，還是坐等java11的釋出再考慮在生產中使用

特性列表

• 區域性變數的型別推斷 var關鍵字
• GC改進和記憶體管理 並行全垃圾回收器 G1
• 垃圾回收器介面
• 執行緒-區域性變數管控
• 合併 JDK 多個程式碼倉庫到一個單獨的儲存庫中
• 新增API：ByteArrayOutputStream
• 新增API：List、Map、Set
• 新增API：java.util.Properties
• 新增API： Collectors收集器
• 其它特性

1、區域性變數的型別推斷 var關鍵字

這個新功能將為Java增加一些語法糖 - 簡化它並改善開發者體驗。新的語法將減少與編寫Java相關的冗長度，同時保持對靜態型別安全性的承諾。

這可能是Java10給開發者帶來的最大的一個新特性。下面主要看例子：

public static void main(String[] args) {
 var list = new ArrayList<String>();
 list.add("hello，world！");
 System.out.println(list);
 }

這是最平常的使用。注意賦值語句右邊，最好寫上泛型型別，否則會有如下情況：

public static void main(String[] args) {
 var list = new ArrayList<>();
 list.add("hello，world！");
 list.add(1);
 list.add(1.01);
 System.out.println(list);
 }

list什麼都可以裝，非常的不安全了。和js等語言不同的是，畢竟Java還是強型別的語言，所以下面語句是編譯報錯的：

public static void main(String[] args) {
 var list = new ArrayList<String>();
 list.add("hello，world！");
 System.out.println(list);
 list = new ArrayList<Integer>(); //編譯報錯
 }

 

注意：下面幾點使用限制

區域性變數初始化

for迴圈內部索引變數

傳統的for迴圈宣告變數

public static void main(String[] args) {
 //區域性變數初始化
 var list = new ArrayList<String>();
 //for迴圈內部索引變數
 for (var s : list) {
 System.out.println(s);
 }
 //傳統的for迴圈宣告變數
 for (var i = 0; i < list.size(); i++) {
 System.out.println(i);
 }
 }

 

下面這幾種情況，都是不能使用var的

方法引數全域性變數

public static var list = new ArrayList<String>(); //編譯報錯

public static List<String> list = new ArrayList<>(); //正常編譯通過

建構函式引數方法返回型別欄位捕獲表示式（或任何其他型別的變數宣告）

 

2、GC改進和記憶體管理 並行全垃圾回收器 G1

JDK 10中有2個JEP專門用於改進當前的垃圾收集元素。

Java 10的第二個JEP是針對G1的並行完全GC（JEP 307），其重點在於通過完全GC並行來改善G1最壞情況的等待時間。G1是Java 9中的預設GC，並且此JEP的目標是使G1平行。

 

3、垃圾回收器介面

這不是讓開發者用來控制垃圾回收的介面；而是一個在 JVM 原始碼中的允許另外的垃圾回收器快速方便的整合的介面。

 

4、執行緒-區域性變數管控

這是在 JVM 內部相當低級別的更改，現在將允許在不執行全域性虛擬機器安全點的情況下實現執行緒回撥。這將使得停止單個執行緒變得可能和便宜，而不是隻能啟用或停止所有執行緒。

 

5、合併 JDK 多個程式碼倉庫到一個單獨的儲存庫中

在 JDK9 中，有 8 個倉庫： root、corba、hotspot、jaxp、jaxws、jdk、langtools 和 nashorn 。在 JDK10 中這些將被合併為一個，使得跨相互依賴的變更集的儲存庫執行 atomic commit （原子提交）成為可能。

 

6、新增API：ByteArrayOutputStream

String toString(Charset): 過載 toString()，通過使用指定的字符集解碼位元組，將緩衝區的內容轉換為字串。

 

7、新增API：List、Map、Set

這3個介面都增加了一個新的靜態方法，copyOf(Collection）。這些函式按照其迭代順序返回一個不可修改的列表、對映或包含給定集合的元素的集合。

 

8、新增API：java.util.Properties

增加了一個新的建構函式，它接受一個 int 引數。這將建立一個沒有預設值的空屬性列表，並且指定初始大小以容納指定的元素數量，而無需動態調整大小。還有一個新的過載的 replace 方法，接受三個 Object 引數並返回一個布林值。只有在當前對映到指定值時，才會替換指定鍵的條目。

 

9、新增API： Collectors收集器

toUnmodifiableList():

toUnmodifiableSet():

toUnmodifiableMap(Function, Function):

toUnmodifiableMap(Function, Function, BinaryOperator):

這四個新方法都返回 Collectors ，將輸入元素聚集到適當的不可修改的集合中。

 

10、其它特性

執行緒本地握手（JEP 312）

其他Unicode語言 - 標記擴充套件（JEP 314）

基於Java的實驗性JIT編譯器

根證書頒發認證（CA）

刪除工具javah（JEP 313）

從JDK中移除了javah工具，這個很簡單並且很重要。

最後

 

JDK10的升級幅度其實主要還是以優化為主，並沒有帶來太多對使用者驚喜的特性。所以建議廣大開發者還是坐等Java11吧，預計2018年9月份就會到來，最重要的是它是LTS版本哦，所以是可以運用在生產上的。

 

Java 11

2018年9月26日，Oracle 官方宣佈 Java 11 正式釋出。這是 Java 大版本週期變化後的第一個長期支援版本（LTS版本，Long-Term-Support，持續支援到2026年9月），非常值得關注。Java11 帶來了 ZGC、Http Client 等重要特性，一共包含 17 個 JEP（JDK Enhancement Proposals，JDK 增強提案）。

 

特性列表

官方新特性：

 

 

本文針對於讀者對關心、也是最實用的八大新特性做出一些講解

• 本地變數型別推斷
• 字串加強
• 集合加強
• Stream 加強
• Optional 加強
• InputStream 加強
• HTTP Client API
• 化繁為簡，一個命令編譯執行原始碼

 

 

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

 

示例2：

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

 

示例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());
 }
}

 

可以看出 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)));
 }

 

Collection.toArray(IntFunction)

在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)));
 }

 

4、Stream 加強

Stream 是 Java 8 中的新特性，Java 9 開始對 Stream 增加了以下 4 個新方法。

增加單個引數構造方法，可為null

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

 

原始碼可看看：

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

 

2、增加 takeWhile 和 dropWhile 方法

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

 

takeWhile表示從開始計算，當 n < 3 時就截止。

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

 

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);
 }

 

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(); // javastac

 

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);
}

 

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 的用法：

上面的 .GET() 可以省略，預設請求方式為 Get！

更多使用示例可以看這個 API，後續有機會再做演示。

現在 Java 自帶了這個 HTTP Client API，我們以後還有必要用 Apache 的 HttpClient 工具包嗎？我覺得沒啥必要了

 

8、化繁為簡，一個命令編譯執行原始碼

看下面的程式碼。

// 編譯
javac Javastack.java
// 執行
java Javastack

 

在我們的認知裡面，要執行一個 Java 原始碼必須先編譯，再執行，兩步執行動作。而在未來的 Java 11 版本中，通過一個 java 命令就直接搞定了，如以下所示。

java Javastack.java

 

移除項

移除了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結合使用。

 

轉自：http://www.cnblogs.com/xdzy/p/10112028.html