JDK1.7新特性（高级篇）

 一、目录

  1 对集合类的语言支持； 

  2 自动资源管理； 

  3 改进的通用实例创建类型推断； 

  4 数字字面量下划线支持； 

  5 switch中使用string； 

  6 二进制字面量； 

  7 简化可变参数方法调用；

  8 新增一些取环境信息的工具方法；

  9 Boolean类型反转，空指针安全,参与位运算；

  10 两个char间的equals；

  11 安全的加减乘除；

  12 map集合支持并发请求 ，且可以写成 Map map = {name:"xxx",age:18}；

  13 捕获多种异常并用改进后的类型检查来重新抛出异常。

二、详细介绍

      1 对集合类的语言支持 

      Java将包含对创建集合类的第一类语言支持。这意味着集合类的创建可以像Ruby和Perl那样了，创建List / Set / Map 时写法更简单了。

  

 List< String> list = ["item"];  
 String item = list[0];  
 Set< String > set = {"item"};  
 Map< String,Integer > map = {"key" : 1};  
 int value = map["key"]; 

 

      原本需要这样： 

         

List<String> list = new ArrayList<String>(); 
list.add("item"); 
String item = list.get(0); 
   
Set<String> set = new HashSet<String>(); 
set.add("item"); 
Map<String, Integer> map = new HashMap<String, Integer>(); 
map.put("key", 1); 
int value = map.get("key"); 

 

      现在你可以这样： 

         

List<String> list = ["item"]; 
String item = list[0]; 
         
Set<String> set = {"item"}; 
         
Map<String, Integer> map = {"key" : 1}; 
int value = map["key"]; 

   

      2 自动资源管理 

      Java中某些资源是需要手动关闭的，如InputStream，Writes，Sockets，Sql classes等。这个新的语言特性允许try语句本身申请更多的资源， 这些资源作用于try代码块，并自动关闭。 

      这个： 

 

 BufferedReader br = new BufferedReader(new FileReader(path)); 
  try { 
         return br.readLine(); 
  } finally { 
         br.close(); 
  } 

 

      变成了这个： 

          

try (BufferedReader br = new BufferedReader(new FileReader(path)) { 
      return br.readLine(); 
} 

    

      你可以定义关闭多个资源： 

         

try ( 
        InputStream in = new FileInputStream(src); 
        OutputStream out = new FileOutputStream(dest)
) { 
        // code 
  } 

 

      为了支持这个行为，所有可关闭的类将被修改为可以实现一个Closable（可关闭的）接口。 

   

      3 增强的对通用实例创建（diamond）的类型推断 

      类型推断是一个特殊的烦恼，下面的代码： 

         

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

 

      通过类型推断后变成： 

 

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

         

      这个<>被叫做diamond（钻石）运算符，这个运算符从引用的声明中推断类型。 

   

      4 数字字面量下划线支持 

      很长的数字可读性不好，在Java 7中可以使用下划线分隔长int以及long了，如： 

         int one_million = 1_000_000; 

   运算时先去除下划线，如：1_1 * 10 = 110，120 – 1_0 = 110 

   

      5 switch中使用string 

      以前你在switch中只能使用number或enum，现在你可以使用string了： 

         

String s = ... 
switch(s) { 
   case "shanghai": 
        processQuux(s); 
        // fall-through 
   case "beijing": 
   case "tianjin": 
      processFooOrBar(s); 
      break; 
   case "hunan": 
       processBaz(s); 
       // fall-through 
   default: 
       processDefault(s); 
       break; 
} 

 

      6 二进制字面量 

 

      由于继承C语言，Java代码在传统上迫使程序员只能使用十进制，八进制或十六进制来表示数(numbers)。 

      由于很少的域是以bit导向的，这种限制可能导致错误。你现在可以使用0b前缀创建二进制字面量： 

         int binary = 0b1001_1001; 

   现在，你可以使用二进制字面量这种表示方式，并且使用非常简短的代码，可将二进制字符转换为数据类型，如在byte或short。 

   byte aByte = (byte)0b001;    

   short aShort = (short)0b010;    

   

      7 简化的可变参数调用 

 

      当程序员试图使用一个不可具体化的可变参数并调用一个*varargs* （可变）方法时，编辑器会生成一个“非安全操作”的警告。 

   JDK 7将警告从call转移到了方法声明(methord declaration)的过程中。这样API设计者就可以使用vararg，因为警告的数量大大减少了。 

 

    8  新增一些取环境信息的工具方法

 

File System.getJavaIoTempDir()  // IO临时文件夹    
File System.getJavaHomeDir() // JRE的安装目录    
File System.getUserHomeDir() // 当前用户目录    
File System.getUserDir() // 启动java进程时所在的目录      

 

   9 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) 

 

10 两个char间的equals

 

boolean  Character.equalsIgnoreCase( char  ch1,  char  ch2)

    

11 安全的加减乘除

 

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)

 

12 map集合支持并发请求 ，且可以写成 Map map = {name:"xxx",age:18};

 

13 捕获多种异常并用改进后的类型检查来重新抛出异常 

 

1、捕获多种异常

在Java SE7里，一个catch可以捕获多个异常，这样可以减少重复代码。每个异常之间用 | 隔开。

 

public static void first(){ 
	try { 
		BufferedReader reader = new BufferedReader(new FileReader(""));
		Connection con = null; 
		Statement stmt = (Statement) 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里一个异常类型的父类或子类。

 

 

 

 

 

 

 

 

 

 

 

 

打赏分享者

          如果这个分享对您提供了帮助，那就打赏我吧，有钱捧个钱场（支持支付宝和微信捐助），没钱捧个人场，有了大家的支持，我们会更有动力，会做的更好的，谢谢各位。