jdk1.7新特性~

来源:互联网 发布:季风书园关闭 知乎 编辑:程序博客网 时间:2024/06/10 23:14

1.   二进制字面量 

JDK7开始,终于可以用二进制来表示整数(byte,short,int和long)。使用二进制字面量的好处是,可以是代码更容易被理解。语法非常简单,只要在二进制数值前面加 0b或者0B

 


Java代码

byte nByte = (byte)0b0001;        

short nShort = (short)0B0010;        

int nInt = 0b0011;        

long nLong = 0b0100L; 

 

2.   数字字面量允许使用下划线 

byte nByte = (byte)0b0001;    

short nShort = (short)0B0010;    

int nInt = 0b0011;    

long nLong = 0b0100L;  

对于一些比较大的数字,我们定义起来总是不方面,经常缺少或者增加位数。JDK7为我们提供了一种解决方案,下划线可以出现在数字字面量。

Java
代码

int a = 10_0000_0000;        

long b = 0xffff_ffff_ffff_ffffl;        

byte c = 0b0001_1000;

byte nByte = (byte)0b0001;    

short nShort = (short)0B0010;    

int nInt = 0b0011;    

long nLong = 0b0100L;  

int a = 10_0000_0000;    

long b = 0xffff_ffff_ffff_ffffl;    

byte c = 0b0001_1000; 


注意:你只能将下划线置于数字之间,以下使用方法是错误的,
1.数字的开头或者结尾
2.
小数点的前后
3.‘F’
或者‘f’的后缀
4.
只能用数字的位置


Java代码

int err1 = _11,err2=11_;    
float err3=3._4,err4=3_.4;   
long err5=0x888_f;

 

3.   switch 语句允许使用字符串

 

这个功能千呼万唤,终于出来了

Java
代码

private static void switchString(String str){                

switch(str){                    

case "one":                        

System.err.println("1");                        

break;                   

 case "two":                        

System.out.println("2");                        

break;                    

default :                        

System.out.println("err");                

}        

}

4.   泛型实例的创建可以通过类型推断来简化 


以后你创建一个泛型实例,不需要再详细说明类型,只需用<>,编译器会自动帮你匹配
Java
代码

//例如         

Map myMap = new HashMap();       

 //可以简化为        

Map myMap = new HashMap<>();   

//例如     

Map> myMap = new HashMap>();   

 //可以简化为    

Map> myMap = new HashMap<>();



5.   在可变参数方法中传递非具体化参数(Non-Reifiable Formal Parameters),改进编译警告和错误

有些参数类型,例如ArrayList List,是非具体化的(non-reifiable).在编译阶段,编译器会擦除该类型信息。

Heap pollution
指一个变量被指向另外一个不是相同类型的变量。例如

Java
代码

List l = new ArrayList();               

List ls = l;       // unchecked warning               

l.add(0, new Integer(42)); // another unchecked warning           

String s = ls.get(0);      // ClassCastException is thrown 

 

List l = new ArrayList();           

List ls = l;       // unchecked warning           

l.add(0, new Integer(42)); // another unchecked warning            String s = ls.get(0);      // ClassCastException is thrown


回到我们的主题,在jdk7中,当你定义下面的函数时

Java代码

public static  void addToList (List listArg, T... elements) {         for (T x : elements) {             

 listArg.add(x);            

 }          

}     

你会得到一个warning   

  

warning: [varargs] Possible heap pollution from parameterized vararg type  

 

 

public static  void addToList (List listArg, T... elements) {         for (T x : elements) {         

 listArg.add(x);        

 }      

你会得到一个warning

 

warning: [varargs] Possible heap pollution from parameterized vararg type



jdk7之前,当你调用一个含有非具体化参数的可变参数方法,你必须自行保证不会发生“heap pollution”。这有一个问题,如果调用者对方法不熟悉,他根本无法判断。JDK7对此做了改进,在该方法被定义时久发出警告

要消除警告,可以有三种方式

1.
annotation @SafeVarargs

2.
annotation @SuppressWarnings({"unchecked", "varargs"})

3.
使用编译器参数 –Xlint:varargs;

6.   try-with-resources 语句

 

jdk7提供了try-with-resources,可以自动关闭相关的资源(只要该资源实现了AutoCloseable接口,jdk7为绝大部分资源对象都实现了这个接口)
Java
代码

static String readFirstLineFromFile(String path) throws IOException {          

try (   

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

     return br.readLine();          

  }        

}   

 

 

static String readFirstLineFromFile(String path) throws IOException {      

try (

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

     return br.readLine();      

  }    


try 语句块中还可以同时处理多个资源,可以跟普通的try语句一样catch异常,有finally语句块

Java
代码

try (              

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

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

 ) {     }   

catch(…){     }   

finally{     }  

 

 

7.   Catch多个Exceptionthrow exception改进了类型检测

 

try (          

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

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

 ) {     }

catch(…){     }

finally{     } 

很多时候,我们捕获了多个异常,却做了相同的事情,比如记日志,包装成新的异常,然后rethrow。这时,代码就不那么优雅了,例如

Java
代码

catch (IOException ex) {             

logger.log(ex);            

 throw ex;       

catch (SQLException ex) {             

logger.log(ex);             

throw ex;        

}  

catch (IOException ex) {         

logger.log(ex);        

 throw ex;   

catch (SQLException ex) {         

logger.log(ex);         

throw ex;    



Jdk7允许捕获多个异常

Java
代码

catch (IOException|SQLException ex) {            

logger.log(ex);            

throw ex;        

   

catch (IOException|SQLException ex) {        

logger.log(ex);        

throw ex;    


注意,catch后面的异常参数是final的,不能重新再复制

Rethrow Exception
更具包容性的类型检测

当你重新抛出多个异常时,不再需要详细定义异常类型了,编译器已经知道你具体抛出的是哪个异常了。你只需在方法定义的时候声明需要抛出的异常即可

Java
代码

public void call() throws ReflectiveOperationException, IOException {            

try {              

callWithReflection(arg);            

}    

catch (final Exception e) {              

logger.trace("Exception in reflection", e);              

throw e;            

}        

   


8.   菱形语法

 

菱形语法(泛型实例化类型自动推断)

 

Java代码

List<String> list = new ArrayList<>(); // <>这个真的很像菱形

   

9.   不可具体化的泛型(任意类型)可变参数

 

List<String> list = new ArrayList<>(); // <>这个真的很像菱形

在目前版本中,不可具体化的泛型(任意类型)可变参数,在编译时,会在调用处产生警告,JDK7里将这个警告挪到了方法定义处。
变化前:

static <T> List<T> asList(T... elements) { ... }  

static List<Callable<String>> stringFactories() {  

     Callable<String> a, b, c;  

     ...  

     // 警告处  

     return asList(a, b, c);  

   } 

 

static <T> List<T> asList(T... elements) { ... }

static List<Callable<String>> stringFactories() {

     Callable<String> a, b, c;

     ...

     // 警告处

     return asList(a, b, c);

   } 

   变化后:

   // 警告处  

static <T> List<T> asList(T... elements) { ... }  

static List<Callable<String>> stringFactories() {  

     Callable<String> a, b, c;  

     ...  

     return asList(a, b, c);  

   } 

 

// 警告处

static <T> List<T> asList(T... elements) { ... }

static List<Callable<String>> stringFactories() {

     Callable<String> a, b, c;

     ...

     return asList(a, b, c);

   } 

 

   3,switch现在可以支持字符串了

   String s = ...  

switch(s) {  

   case "quux":  

     processQuux(s); //没有break,继续往下  

 

   case "foo":  

   case "bar":  

     processFooOrBar(s);  

     break;  

   case "baz":  

     processBaz(s); //没有break,继续往下  

 

   default:  

     processDefault(s);  

     break;  

 

String s = ...

switch(s) {

   case "quux":

     processQuux(s); //没有break,继续往下

 

   case "foo":

   case "bar":

     processFooOrBar(s);

     break;

   case "baz":

     processBaz(s); //没有break,继续往下

 

   default:

     processDefault(s);

     break;

}


Java代码

static <T> List<T> asList(T... elements) { ... }      

static List<Callable<String>> stringFactories() {      

     Callable<String> a, b, c;      

     ...      

     // 警告处      

     return asList(a, b, c);      

   }     

  

static <T> List<T> asList(T... elements) { ... }   

static List<Callable<String>> stringFactories() {   

     Callable<String> a, b, c;   

     ...   

     // 警告处   

     return asList(a, b, c);   

   }     

   变化后:   

   // 警告处      

static <T> List<T> asList(T... elements) { ... }      

static List<Callable<String>> stringFactories() {      

     Callable<String> a, b, c;      

     ...      

     return asList(a, b, c);      

   }     

  

// 警告处   

static <T> List<T> asList(T... elements) { ... }   

static List<Callable<String>> stringFactories() {   

     Callable<String> a, b, c;   

     ...   

     return asList(a, b, c);   

   }     

  

   3switch现在可以支持字符串了   

   String s = ...      

switch(s) {      

   case "quux":      

     processQuux(s); //没有break,继续往下      

     

   case "foo":      

   case "bar":      

     processFooOrBar(s);      

     break;      

   case "baz":      

     processBaz(s); //没有break,继续往下      

     

   default:      

     processDefault(s);      

     break;      

}     

  

String s = ...   

switch(s) {   

   case "quux":   

     processQuux(s); //没有break,继续往下   

  

   case "foo":   

   case "bar":   

     processFooOrBar(s);   

     break;   

   case "baz":   

     processBaz(s); //没有break,继续往下   

  

   default:   

     processDefault(s);   

     break;   

}  

 

 

10.      支持二进制语法和单位级别的数字表示方式

 

Java代码

// 8byte      

byte aByte = (byte)0b00100001;      

// 16short      

short aShort = (short)0b1010000101000101;      

// 32int      

int anInt1 = 0b10100001010001011010000101000101;     

  

// 8byte   

byte aByte = (byte)0b00100001;   

// 16short   

short aShort = (short)0b1010000101000101;   

// 32int   

int anInt1 = 0b10100001010001011010000101000101;     

支持单位级别的数字,提高可读性   

long underScores = 9_223_372_036_854_775_807L; // 每三位加一下划线,等同于 9,223,372,036,854,775,807     

  

long underScores = 9_223_372_036_854_775_807L; // 每三位加一下划线,等同于 9,223,372,036,854,775,807

   

11.      从语法层面上支持集合,不再是数组的专利

 

Java代码

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

final Set<Integer> primes = { 2, 7, 31, 127, 8191, 131071, 524287 };      

final Map<Integer, String> platonicSolids = { 4 : "tetrahedron",      

6 : "cube", 8 : "octahedron", 12 : "dodecahedron", 20 : "icosahedron"     

};     

  

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

final Set<Integer> primes = { 2, 7, 31, 127, 8191, 131071, 524287 };   

final Map<Integer, String> platonicSolids = { 4 : "tetrahedron",   

6 : "cube", 8 : "octahedron", 12 : "dodecahedron", 20 : "icosahedron"  

};  

12.      JSR 292 动态类型语言支持

 

Java代码

Dynamic x = (动态语言脚本);      

Object   y = x.foo("ABC").bar(42).baz();     

  

Dynamic x = (动态语言脚本);   

Object   y = x.foo("ABC").bar(42).baz();  

13.      动态资源管理

 

Dynamic x = (动态语言脚本);  

Object   y = x.foo("ABC").bar(42).baz(); 

 

Dynamic x = (动态语言脚本);

Object   y = x.foo("ABC").bar(42).baz();

\
在目前版本的java中,当你操作流时,一定会加try..finally以保证出现异常时,流能被正确关闭。

 

Java代码

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

try {      

     return br.readLine();      

} finally {      

     br.close();      

}     

  

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

try {   

     return br.readLine();   

} finally {   

     br.close();   

}  

   

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

try {  

     return br.readLine();  

} finally {  

     br.close();  

 

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

try {

     return br.readLine();

} finally {

     br.close();

}


JDK7里,你只需要将资源定义在try()里,Java7就会在readLine抛异常时,自动关闭资源。另外,资源类必须实现 Disposable<?> 接口。支持管理多个资源

Java代码

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

     return br.readLine();      

   

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

     return br.readLine();  

}

 

原创粉丝点击