Java 7新特性深度解析：提升效率與功能

一、Switch中添加對String類型的支持

Switch語句可以使用原始類型或枚舉類型。

Java引入了另一種類型，可以在switch語句中使用：字符串類型。

public class switchAddString {public static void main(String[] args) {String s = "a";switch (s) {case "a":System.out.println("a");break; case "b":System.out.println("b");break;default:System.out.println("default");}}
}

編譯器在編譯時的處理情形

1. 僅有一個case和default，則直接轉換為if…else… 。
2. 有多個case。先將String轉換為hashCode，然后相應的進行處理。

二、數字字面量的改進

1. 數字中可加入分隔符：
   • Java7中支持在數字量中間添加’_’作為分隔符。
   • 下劃線僅僅能在數字中間。
   • 編譯時編譯器自己主動刪除數字中的下劃線。
2. Java7添加二進制表示。

public static void main(String[] args) {int i = 10;System.out.println("i=" + i);// 二進制int j = 0b1010;// 十六進制int k = 0x1234;// 1,000,000int l = 1_000_000;// 1,000,000int m = 1__000_000;System.out.println("j=" + j);System.out.println("k=" + k);System.out.println("l=" + l);System.out.println("m=" + m);}

三、異常處理（捕獲多個異常）

1. catch子句能夠同一時候捕獲多個異常：
   • 使用’|'切割，多個類型，一個對象e 。
2. try-with-resources語句：
   • Java7之前須要在finally中關閉socket、文件、數據庫連接等資源。
   • Java7引入try-with-resources，用于確保資源在使用后能夠正確地關閉。
   • 在使用try-with-resources時，你可以在 try 關鍵字后面的括號中聲明一個或多個資源。
   • 這些資源必須實現 AutoCloseable 接口（Java 7引入的接口，它具有一個 close() 方法用于釋放資源）。

public static void main(String[] args) {// 捕獲多個異常try {int a = 10;int b = 0;System.out.println("a/b=" + (a / b));} catch (ArithmeticException | NullPointerException e) {e.printStackTrace();}// try-with-resources，在 try 關鍵字后面的括號中聲明一個或多個資源，每個資源用逗號分隔String fileName = "example.txt";try (// 使用try-with-resources聲明BufferedReader資源BufferedReader reader = new BufferedReader(new FileReader(fileName));// 需要聲明多個資源，我們只需在括號中用逗號分隔BufferedReader reader1 = new BufferedReader(new FileReader("file1.txt"));BufferedReader reader2 = new BufferedReader(new FileReader("file2.txt"))) {// 讀取文件內容String line;while ((line = reader.readLine()) != null) {System.out.println(line);}// 這里不需要顯式調用reader.close()，因為try-with-resources會自動處理} catch (IOException e) {// 處理可能發生的IOExceptione.printStackTrace();}// 在try代碼塊執行完畢后，reader會被自動關閉}

四、增強泛型推斷

1. 菱形操作符：
   • 在實例化泛型類時，可以使用菱形操作符 <> 來省略類型參數。
   • 編譯器會根據上下文推斷類型參數。
   • 簡化代碼，減少冗余，提高代碼的可讀性。
2. 泛型實例化類型推斷：
   • 當泛型類的構造函數的參數包含泛型類型時，Java 7 能夠推斷泛型的類型。
   • 這允許你在實例化泛型類時省略類型參數，只在構造函數參數中指定類型即可。

public static void main(String[] args) {// Java7之前ArrayList<String> arrayList = new ArrayList<String>();// Java7之后ArrayList<String> arrayList2 = new ArrayList<>();// 泛型類class Generic<T> {// 構造函數參數為泛型類型public Generic(T t) {}}// 使用泛型實例化類型推斷Generic<String> generic = new Generic<>("abc");}

五、NIO2.0（AIO）新IO的支持

Java 7 引入了 NIO 2.0（New I/O），其中包含對異步 I/O（AIO）的支持，這是一個顯著的新特性，特別是在處理非阻塞 I/O 操作時非常有用。具體來說，NIO 2.0 的 AIO 支持通過引入 AsynchronousFileChannel 類來實現異步文件 I/O 操作。

1. AsynchronousFileChannel 類：
   • 允許進行異步文件讀取和寫入操作。
   • 相比于傳統的阻塞 I/O，異步 I/O 可以在讀寫數據的同時執行其他操作，從而提高系統的效率和性能。

public static void main(String[] args) throws Exception {// 異步讀取文件Path path = Paths.get("file.txt");AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);// 分配緩沖區ByteBuffer buffer = ByteBuffer.allocate(1024);// 讀取文件long position = 0;// 異步讀取數據，用于檢查讀取操作的狀態和獲取讀取的結果Future<Integer> operation = fileChannel.read(buffer, position);while (!operation.isDone()) {// 等待讀取完成Thread.sleep(1000);}// 讀取完成，將緩沖區數據翻轉buffer.flip();// 讀取數據byte[] data = new byte[buffer.limit()];// 將緩沖區數據復制到data中buffer.get(data);System.out.println(new String(data));// 關閉文件fileChannel.close();}

2. AsynchronousServerSocketChannel 和 AsynchronousSocketChannel：
   • 用于支持異步的網絡編程。
   • 這些類允許你創建異步服務器端和客戶端，并進行異步的網絡數據讀取和寫入操作。
   • 在高并發環境下處理 I/O 操作變得更為高效和靈活。

public static void main(String[] args) throws Exception {// 創建異步通道AsynchronousServerSocketChannel serverChannel =AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8080));// 接受連接serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {/*** 接受連接完成時調用此方法。* @param clientChannel* @param attachment*/@Overridepublic void completed(AsynchronousSocketChannel clientChannel, Void attachment) {// 繼續接受連接serverChannel.accept(null, this);// 讀取數據ByteBuffer buffer = ByteBuffer.allocate(1024);// 異步讀取數據clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {/*** 當讀取操作完成時調用此方法。** @param result 讀取操作的結果，通常為讀取的字節數，但在此處未使用* @param attachment 包含讀取數據的ByteBuffer對象*/@Overridepublic void completed(Integer result, ByteBuffer attachment) {// 處理讀取完成attachment.flip();// 讀取數據byte[] data = new byte[attachment.limit()];// 將數據復制到數組中attachment.get(data);System.out.println(new String(data));}/*** 讀取操作失敗時調用此方法。* @param exc* @param attachment*/@Overridepublic void failed(Throwable exc, ByteBuffer attachment) {// 處理讀取失敗}});}/*** 接受連接失敗時調用此方法。* @param exc* @param attachment*/@Overridepublic void failed(Throwable exc, Void attachment) {// 處理接受連接失敗}});// 程序繼續執行其他操作Thread.sleep(Long.MAX_VALUE);}

六、SR292與InvokeDynamic

1. SR-292（Small Ranges）：
   • SR-292 是 Java 7 中引入的一個改進，主要針對 switch 語句的性能優化。
   • 在早期的 Java 版本中，switch 語句的效率問題在于它通過逐個比較每個 case 條件來確定執行的分支，如果分支很多，這個過程可能會很慢。
   • SR-292 引入了一種優化，即當 switch 語句的 case 常量之間的距離非常小（稱為 “small ranges”），Java 編譯器會使用一種更有效的查找方式，而不是簡單的逐個比較。
   • 這種方式可以顯著提高 switch 語句的執行速度，特別是在處理密集的條件分支時。

public static void main(String[] args) {int month = 3;String monthName;// Java 7 的 SR-292 特性可以在一些情況下優化這樣的 switch 語句，尤其是在 case 常量的范圍較小時switch (month) {case 1:monthName = "January";break;case 2:monthName = "February";break;case 3:monthName = "March";break;case 4:monthName = "April";break;case 5:monthName = "May";break;case 6:monthName = "June";break;default:monthName = "Unknown";break;}System.out.println("Month: " + monthName);}

2. InvokeDynamic（動態方法調用）：
   • InvokeDynamic 是 Java 7 引入的另一個重要特性，它是 Java 虛擬機（JVM）層面的改進，旨在支持更靈活和高效的動態語言實現。
   • 允許 Java 代碼中的方法調用在運行時動態解析，并且可以綁定到相應的方法實現。
   • 用來優化字節碼生成和方法調用的性能。
   • Java 8 的 Lambda 表達式依賴于 InvokeDynamic 來生成相應的字節碼。

public static void main(String[] args) throws Throwable {// 創建動態調用MethodHandles.Lookup lookup = MethodHandles.lookup();// 創建方法句柄，使用lookup對象來查找Math.class中的靜態方法sqrt，該方法接受一個double參數并返回一個dou* 第一個參數是`lookup`對象。MethodHandle mh = lookup.findStatic(Math.class, "sqrt",MethodType.methodType(double.class, double.class));// 創建動態調用// 第一個參數是`lookup`對象// 第二個參數是方法名，這里使用`"apply"`，因為它是`Function`接口中唯一的方法。// 第三個參數是`Function`接口的簽名（即`Function.class`的類型）。// 第四個參數是`mh`的泛型類型簽名。// 第五個參數是我們要調用的方法句柄（即`mh`）。// 第六個參數是`mh`的類型簽名，表示我們要調用的方法的實際類型。CallSite sqrt = LambdaMetafactory.metafactory(lookup, "apply",MethodType.methodType(Function.class),mh.type().generic(),mh,mh.type());// 調用動態調用MethodHandle factory = sqrt.getTarget();// 調用工廠方法，得到一個Function對象，使用了強制類型轉換，因為factory.invoke()返回的是一個ObjectFunction<Double, Double> sqrtFunc = (Function<Double, Double>) factory.invoke();double result = sqrtFunc.apply(16.0);System.out.println("Square root of 16: " + result);}

七、Path接口

在 Java 7 之前，通常使用 java.io.File 類來處理文件路徑，Java 7 引入了 java.nio.file.Path 接口，它是 Java 中操作文件和目錄路徑的抽象表示。 Path 接口提供了更多功能和更強大的操作能力。

Path 接口的一些主要特性和用法：

1. 路徑表示：

   • Path 接口可以表示文件系統中的路徑，可以是文件或目錄。它不僅僅是一個字符串，而是一個真正的對象，提供了豐富的方法來操作路徑。

2. 創建路徑：

   • 可以使用Paths 類的靜態方法來創建 Path 對象

     Path path = Paths.get("/path/to/file.txt");
     

3. 路徑操作：

   • Path 接口提供了多種方法來獲取路徑的信息
     • toString()：將路徑轉換為字符串表示。
     • getFileName()：獲取路徑中的文件名部分。
     • getParent()：獲取路徑中的父路徑。
     • getRoot()：獲取路徑的根部分。
     • getNameCount()：獲取路徑中的名稱元素的數量。
     • subpath(int beginIndex, int endIndex)：獲取指定范圍內的子路徑。

4. 路徑解析：

   • resolve() 方法可以用于解析相對路徑或者連接兩個路徑，返回一個新的路徑對象。

5. 檢查路徑屬性：

   • 可以使用 Files 類的靜態方法來檢查文件或目錄的屬性，例如是否存在、是否可讀、是否可寫等。

6. 文件操作：

   • Files 類結合 Path 接口提供了豐富的文件操作功能，包括讀取文件內容、寫入文件、復制、移動、刪除等。

7. 路徑迭代：

   • Path接口支持迭代，可以方便地遍歷路徑的各個部分。

     for (Path element : path) {System.out.println(element);
     }
     

8. 相對路徑和絕對路徑：

   • Path 接口可以表示相對路徑和絕對路徑，并提供了方法來轉換和處理這兩種路徑。

public static void main(String[] args) {// 創建一個 Path 對象Path path = Paths.get("/path/to/file.txt");// 獲取文件名Path fileName = path.getFileName();System.out.println("File Name: " + fileName);// 獲取父路徑Path parent = path.getParent();System.out.println("Parent Path: " + parent);// 獲取路徑的根部分Path root = path.getRoot();System.out.println("Root of the path: " + root);// 獲取路徑的元素數量int nameCount = path.getNameCount();System.out.println("Number of elements in the path: " + nameCount);// 遍歷路徑的每個元素System.out.println("Elements in the path:");for (int i = 0; i < nameCount; i++) {System.out.println("Element " + i + ": " + path.getName(i));}// 路徑解析示例Path resolvedPath = path.resolve("subdir");System.out.println("Resolved Path: " + resolvedPath);// 檢查文件或目錄的屬性// 判斷文件是否存在boolean exists = Files.exists(path);System.out.println("Exists: " + exists);// 判斷文件是否是目錄boolean isReadable = Files.isReadable(path);System.out.println("Readable: " + isReadable);// 判斷文件是否是可寫boolean isWritable = Files.isWritable(path);System.out.println("Writable: " + isWritable);// 讀取文件內容Path filePath = Paths.get("/path/to/file.txt");List<String> lines = null;try {lines = Files.readAllLines(filePath, StandardCharsets.UTF_8);} catch (IOException e) {throw new RuntimeException(e);}for (String line : lines) {System.out.println(line);}// 寫入文件內容Path newFilePath = Paths.get("/path/to/newfile.txt");String content = "Hello, Java 7!";try {Files.write(newFilePath, content.getBytes());} catch (IOException e) {throw new RuntimeException(e);}// 復制文件Path copiedFilePath = Paths.get("/path/to/copiedfile.txt");try {Files.copy(filePath, copiedFilePath, StandardCopyOption.REPLACE_EXISTING);} catch (IOException e) {throw new RuntimeException(e);}// 移動文件Path targetPath = Paths.get("/path/to/targetdir/movedfile.txt");try {Files.move(filePath, targetPath, StandardCopyOption.REPLACE_EXISTING);} catch (IOException e) {throw new RuntimeException(e);}// 刪除文件try {Files.delete(filePath);} catch (IOException e) {throw new RuntimeException(e);}}

八、fork/join計算框架

Java 7 引入了 Fork/Join 框架，是一種并行計算框架，專門用于解決分而治之的問題。主要用于執行遞歸式地將問題劃分為更小子問題，并行執行這些子問題的計算，然后合并結果的任務。

使用 Fork/Join 框架的基本步驟：

1. 定義任務類 (RecursiveTask 或 RecursiveAction):
   • RecursiveTask: 用于有返回值的任務。
   • RecursiveAction: 用于無返回值的任務。
2. 重寫 compute() 方法:
   • 在任務類中，需要實現 compute() 方法來定義任務的具體執行邏輯。
   • 通常會判斷是否需要進一步拆分任務，執行子任務的計算，最終將子任務的結果合并或處理。
3. 創建 Fork/Join 池:
   • 使用 ForkJoinPool 類來管理并發執行的任務。
   • 通常可以通過 ForkJoinPool.commonPool() 方法來獲取默認的線程池，也可以根據需要創建自定義的線程池。
4. 提交任務:
   • 將任務提交給 ForkJoinPool 來執行。

使用 Fork/Join 框架來計算數組的總和Demo：

import java.util.concurrent.*;// 繼承 RecursiveTask 來實現有返回值的任務
class SumTask extends RecursiveTask<Long> {// 閾值，控制任務拆分的粒度private static final int THRESHOLD = 10;private int[] array;private int start;private int end;public SumTask(int[] array, int start, int end) {this.array = array;this.start = start;this.end = end;}@Overrideprotected Long compute() {if (end - start <= THRESHOLD) {// 如果任務足夠小，直接計算結果long sum = 0;for (int i = start; i < end; i++) {sum += array[i];}return sum;} else {// 否則，拆分任務為更小的子任務int mid = (start + end) / 2;SumTask leftTask = new SumTask(array, start, mid);SumTask rightTask = new SumTask(array, mid, end);// 異步執行左邊的子任務leftTask.fork();// 同步執行右邊的子任務long rightResult = rightTask.compute(); // 獲取左邊子任務的結果long leftResult = leftTask.join(); // 合并子任務的結果return leftResult + rightResult;}}
}public class ForkJoinDemo {public static void main(String[] args) {int[] array = new int[100];for (int i = 0; i < array.length; i++) {array[i] = i;}// 創建 Fork/Join 線程池ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();// 創建任務并提交給 Fork/Join 線程池SumTask task = new SumTask(array, 0, array.length);long result = forkJoinPool.invoke(task);// 輸出計算結果System.out.println("Sum: " + result);}
}

如果你累了，學會休息，而不是放棄