jdk新特性研究

1.switch中可以使用字串了

String s = "test";

switch (s) {

case "test" :

     System.out.println("test");

case "test1" :

    System.out.println("test1");

    break ;

default :

    System.out.println("break");

    break ;

}

2.運用List<String> tempList = new ArrayList<>(); 即泛型執行個體化類型自動推斷

3.文法上支援集合，而不一定是數組

 final List<Integer> piDigits = [ 1,2,3,4,5,8 ];

4.新增一些取環境資訊的工具方法

 File System.getJavaIoTempDir() // IO臨時檔案夾

 File System.getJavaHomeDir() // JRE的安裝目錄

 File System.getUserHomeDir() // 目前使用者目錄

 File System.getUserDir() // 啟動java程序時所在的目錄5

5.Boolean類型反轉，空指針安全,參與位運算

 Boolean Booleans.negate(Boolean booleanObj)

 True => False , False => True, Null => Null

 boolean Booleans.and(boolean[] array)

 boolean Booleans.or(boolean[] array)

 boolean Booleans.xor(boolean[] array)

 boolean Booleans.and(Boolean[] array)

 boolean Booleans.or(Boolean[] array)

 boolean Booleans.xor(Boolean[] array)

6.兩個char間的equals

 boolean Character.equalsIgnoreCase(char ch1, char ch2)

7.安全的加減乘除

 int Math.safeToInt(long value)

 int Math.safeNegate(int value)

 long Math.safeSubtract(long value1, int value2)

 long Math.safeSubtract(long value1, long value2)

 int Math.safeMultiply(int value1, int value2)

 long Math.safeMultiply(long value1, int value2)

 long Math.safeMultiply(long value1, long value2)

 long Math.safeNegate(long value)

 int Math.safeAdd(int value1, int value2)

 long Math.safeAdd(long value1, int value2)

 long Math.safeAdd(long value1, long value2)

 int Math.safeSubtract(int value1, int value2)

8.map集合支援并發請求，且可以寫成 Map map = {name:"xxx",age:18};

9.對Java集合（Collections）的增強支援

在JDK1.7之前的版本中，Java集合容器中存取元素的形式如下：

以List、Set、Map集合容器為例：

在JDK1.7中，摒棄了Java集合接口的實作類，如：ArrayList、HashSet和HashMap。而是直接采用[]、{}的形式存入對象，采用[]的形式按照索引、鍵值來擷取集合中的對象，如下：

10.數值可加下劃線

例如：int one_million = 1_000_000;

11.支援二進制文字

例如：int binary = 0b1001_1001;

12.簡化了可變參數方法的調用

當程式員試圖使用一個不可具體化的可變參數并調用一個*varargs* （可變）方法時，編輯器會生成一個“非安全操作”的警告。 

13.自動資源管理

14. try-with-resources 聲明

  try-with-resources 是一個定義了一個或多個資源的try 聲明，這個資源是指程式處理完它之後需要關閉它的對象。try-with-resources 確定每一個資源在處理完成後都會被關閉。

可以使用try-with-resources的資源有：

任何實作了java.lang.AutoCloseable 接口和java.io.Closeable 接口的對象。

來看例子：

public static String readFirstLineFromFile(String path) throws IOException {  

     try (BufferedReader br = new BufferedReader(new FileReader(path))) {  

       return br.readLine();  

     }  

}  

   在java 7 以及以後的版本裡，BufferedReader實作了java.lang.AutoCloseable接口。

   由于BufferedReader定義在try-with-resources 聲明裡，無論try語句正常還是異常的結束，

   它都會自動的關掉。而在java7以前，你需要使用finally塊來關掉這個對象。

public static String readFirstLineFromFileWithFinallyBlock(String path) throws IOException {  

   BufferedReader br = new BufferedReader(new FileReader(path));  

   try {  

      return br.readLine();  

   } finally {  

      if (br != null) br.close();  

   }  

 }  

  然而，如果 readLine() 和 close() 這兩個方法都抛出異常，那麼readFirstLineFromFileWithFinallyBlock 方法隻會抛出後面部分也就是finally塊中的内容，try塊中的異常就被抑制了，對于我們的程式來說，這顯然不是一種好的方式。

  而在java 7中，無論是try塊還是try-with-resource中抛出異常，都能捕捉到。

另外，一個try-with-resourcse聲明了可以包含多個對象的聲明，用分号隔開，和聲明一個對象相同，會在結束後自動調用close方法，調用順序和生命順序相反。

try (

  java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);

  java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(outputFilePath, charset)

) {

// do something

}

此外，try-with-resources 可以跟catch和finally，catch和finally的是在try-with-resources裡聲明的對象關閉之後才執行的。

15.捕獲多種異常并用改進後的類型檢查來重新抛出異常

  1、捕獲多種異常

在Java SE7裡，一個catch可以捕獲多個異常，這樣可以減少重複代碼。每個異常之間用 | 隔開。

public static void first(){  

 try {  

  BufferedReader reader = new BufferedReader(new FileReader(""));  

  Connection con = null;  

  Statement stmt = con.createStatement();  

 } catch (IOException | SQLException e) {  

   //捕獲多個異常，e就是final類型的  

   e.printStackTrace();  

    }  

}  

   而在Java SE6以前，需要這樣寫

   Java代碼 

      public static void second() {  

  try {  

    BufferedReader reader = new BufferedReader(new FileReader(""));  

    Connection con = null;  

    Statement stmt = con.createStatement();  

  } catch (IOException e) {  

        e.printStackTrace();  

    } catch (SQLException e) {  

        e.printStackTrace();  

    }  

}  

   注意，如果一個catch處理了多個異常，那麼這個catch的參數預設就是final的，你不能在catch塊裡修改它的值。

另外，用一個catch處理多個異常，比用多個catch每個處理一個異常生成的位元組碼要更小更高效。

2、用更包容性的類型檢查來重新抛出異常

在方法的聲明上，使用throws語句時，你可以指定更加詳細的異常類型。

static class FirstException extends Exception { }  

static class SecondException extends Exception { }  

public void rethrowException(String exceptionName) throws Exception {  

  try {  

     if (exceptionName.equals("First")) {  

         throw new FirstException();  

     } else {  

         throw new SecondException();  

     }  

  } catch (Exception e) {  

   throw e;  

  }  

 }  

這個例子，try塊中隻能抛出兩種異常，但是因為catch裡的類型是 Exception，在java SE7以前的版本中，在方法聲明中throws 隻能寫Exception，但是在java SE7及以後的版本中，可以在throws後面寫 FirstException和SecondException——編譯器能判斷出throw e語句抛出的異常一定來自try塊，并且try塊隻能抛出FirstException和SecondException。

public static void reThrowException(String exceptionName) throws FirstException, SecondException{  

 try {  

    if ("first".equals(exceptionName))  

       throw new FirstException();  

    else  

       throw new SecondException();  

 } catch (Exception e) {  

       throw e;  

 }  

}  

是以盡管catch裡的異常類型是Exception，編譯器仍然能夠知道它是FirstException和 SecondException的執行個體。怎麼樣，編譯器變得更智能了吧。

但是，如果在catch裡對異常重新指派了，在方法的throws後無法再象上面那樣寫成FirstException和SecondException了，而需要寫成 Exception。

具體來說，在Java SE 7及以後版本中，當你在catch語句裡聲明了一個或多個異常類型，并且在catch塊裡重新抛出了這些異常，編譯器根據下面幾個條件來去核實異常的類型：

- Try塊裡抛出它

- 前面沒有catch塊處理它

- 它是catch裡一個異常類型的父類或子類。

在開源java工具包裡，最有名的當屬apache commons。其中，以commons lang包最為開發者熟知。

但是它作為第三方包存在，或多或少給開發者帶來一些不便利。

面包牛奶總是會有的，從java7開始，lang包中的一些優秀工具方法，将被正式引入JDK。

下面是各個已确定被引入的工具類或方法說明。

1. 新增類 java.util.Objects (JDK對工具類的命名一向是以s結尾，例如Collections, Arrays)

A, 空指針安全的 equals, hashCode, toString, defaultNull 方法。

即入參傳入NULL，工具方法不會抛空指針異常。

調用方法舉例：

Boolean result = Objects.equals(obj1, obj2);

B, 比較對象的大小（需要實作Comparable）。

T Objects.max(T comparable1, T comparable2)

T Objects.min(T comparable1, T comparable2)

2. 系統工具類新增一些取環境資訊的工具方法。 (java.lang.System)

以往，你需要通過 System.getProperties(”user.dir”) 這樣來取。現在隻需要調用一下工具方法就可以了。

File System.getJavaIoTempDir() // IO臨時檔案夾

File System.getJavaHomeDir() // JRE的安裝目錄

File System.getUserHomeDir() // 目前使用者目錄

File System.getUserDir() // 啟動java程序時所在的目錄

3. 包裝類型安全轉換到原始類型的工具方法。

boolean Boolean.booleanValue(Boolean obj, boolean defaultValue)

char Character.charValue(Character obj, char defaultValue)

byte Byte.byteValue(Byte obj)

byte Byte.byteValue(Byte obj, byte defaultValue)

short Short.shortValue(Short obj)

short Short.shortValue(Short obj, short defaultValue)

int Integer.intValue(Integer obj)

int Integer.intValue(Integer obj, int defaultValue)

long Long.longValue(Long obj)

long Long.longValue(Long obj, long defaultValue)

float Float.floatValue(Float obj)

float Float.floatValue(Float obj, float defaultValue)

double Double.doubleValue(Double obj)

double Double.doubleValue(Double obj, double defaultValue)

4. 針對包裝類型的Boolean，提供了更具可讀性和空指針安全的工具方法。

boolean Booleans.isTrue(Boolean booleanObj)

boolean Booleans.isFalse(Boolean booleanObj)

boolean Booleans.isNotTrue(Boolean booleanObj)

boolean Booleans.isNotFalse(Boolean booleanObj)

5. Boolean類型反轉，空指針安全

Boolean Booleans.negate(Boolean booleanObj)

True => False , False => True, Null => Null

6. Boolean參與位運算

boolean Booleans.and(boolean[] array)

boolean Booleans.or(boolean[] array)

boolean Booleans.xor(boolean[] array)

boolean Booleans.and(Boolean[] array)

boolean Booleans.or(Boolean[] array)

boolean Booleans.xor(Boolean[] array)

7. 兩個char間的equals

boolean Character.equalsIgnoreCase(char ch1, char ch2)

8. 聲明一批空數組常量，各種類型

Boolean[] Boolean.EMPTY_ARRAY

boolean[] Boolean.EMPTY_PRIMITIVE_ARRAY

Character[] Character.EMPTY_ARRAY

char[] Character.EMPTY_PRIMITIVE_ARRAY

Byte[] Byte.EMPTY_ARRAY

byte[] Byte.EMPTY_PRIMITIVE_ARRAY

Short[] Short.EMPTY_ARRAY

short[] Short.EMPTY_PRIMITIVE_ARRAY

Integer[] Integer.EMPTY_ARRAY

int[] Integer.EMPTY_PRIMITIVE_ARRAY

Long[] Long.EMPTY_ARRAY

long[] Long.EMPTY_PRIMITIVE_ARRAY

Float[] Float.EMPTY_ARRAY

float[] Float.EMPTY_PRIMITIVE_ARRAY

Double[] Double.EMPTY_ARRAY

double[] Double.EMPTY_PRIMITIVE_ARRAY

String[] String.EMPTY_ARRAY

Class[] Class.EMPTY_ARRAY

Object[] Objects.EMPTY_OBJECT_ARRAY

甚至通過Class類型來取空數組。

Boolean.class.emptyArray();

9. 數組長度判定工具類，空指針安全

boolean Arrays.isEmpty(Object[] array)

int Arrays.size(Object[] array)

10. 集合長度判定工具類，空指針安全

boolean Collections.isEmpty(Collection coll)

int Collections.size(Collection coll)

boolean Collections.isEmpty(Map map)

int Collections.size(Map map)

11. 空指針安全的ClassName擷取

String Class.getName(Class cls)

String Class.getSimpleName(Class cls)

String Class.getPackageName(Class cls)

12. 可以直接解析locale資訊字元串的工具方法

Locale parse(String localeStr)

13. 提供根據語言取國家清單或根據國家取語言清單的工具方法

List Locale.countriesByLanguage(String langaugeStr)

List Locale.languagesByCountry(String countryStr)

14. 安全的加減乘除

int Math.safeToInt(long value)

int Math.safeNegate(int value)

long Math.safeNegate(long value)

int Math.safeAdd(int value1, int value2)

long Math.safeAdd(long value1, int value2)

long Math.safeAdd(long value1, long value2)

int Math.safeSubtract(int value1, int value2)

long Math.safeSubtract(long value1, int value2)

long Math.safeSubtract(long value1, long value2)

int Math.safeMultiply(int value1, int value2)

long Math.safeMultiply(long value1, int value2)

long Math.safeMultiply(long value1, long value2)

JDK1.7的新特性：

首先是子產品化特性：現在的 Java7也是采用了子產品的劃分方式來提速，一些不是必須的子產品并沒有下載下傳和安裝，是以在使用全新的Java7的虛拟機的時候會發現真的很快，當虛拟機需要用到某些功能的時候，再下載下傳和啟用相應的子產品，這樣使得最初需要下載下傳的虛拟機大小得到了有效的控制。同時對啟動速度也有了很大的改善。如果你對 OpenJDK的架構比較熟悉，你甚至可以定制JDK的子產品。

其次是多語言支援：這裡的多語言不是指中文英文之類的語言，而是說Java7的虛拟機對多種動态程式語言增加了支援，比如：Rubby、 Python等等。對這些動态語言的支援極大地擴充了Java虛拟機的能力。對于那些熟悉這些動态語言的程式員而言，在使用Java虛拟機的過程中同樣可以使用它們熟悉的語言進行功能的編寫，而這些語言是跑在功能強大的JVM之上的。

再有是開發者的開發效率得到了改善：Java7通過多種特性來增強開發效率。比如對語言本身做了一些細小的改變來簡化程式的編寫，在多線程并發與控制方面：輕量級的分離與合并架構，一個支援并發通路的HashMap等等。通過注解增強程式的靜态檢查。提供了一些新的API用于檔案系統的通路、異步的輸入輸出操作、Socket通道的配置與綁定、多點資料包的傳送等等。

最後是執行效率的提高，也是給人感覺最真切體驗的特性：壓縮了64位的對象指針，Java7通過對對象指針由 64位壓縮到與32位指針相比對的技術使得記憶體和記憶體帶塊的消耗得到了很大的降低因而提高了執行效率。此外還提供了新的垃圾回收機制（G1）來降低垃圾回收的負載和增強垃圾回收的效果。G1垃圾回收機制擁有更低的暫停率和更好的可預測性。