java7 新特性

1. switch中增加对String类型的支持。

public String generate(String name, String gender) {    
       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以前版本。

1. 数字字面量的改进
   十进制：默认的
   八进制：整数之前加数字0来表示
   十六进制：整数之前加“0x”或“0X”
   二进制（新加的）：整数之前加“0b”或“0B”
   在数值字面量中使用下划线
   在java 7中，数值字面量，不管是整数还是浮点数，都允许在数字之间插入任意多个下划线。这些下划线不会对字面量的数值产生影响，目的就是方便阅读。
   比如：
   1_500_000
   5_6.3_4
   89_3___1

3.异常处理
①Throwable类增加addSuppressed方法和getSuppressed方法，支持原始异常中加入被抑制的异常。
异常抑制：在try和finally中同时抛出异常时，finally中抛出的异常会在异常栈中向上传递，而try中产生的原始异常会消失。
在Java7之前的版本，可以将原始异常保存，在finally中产生异常时抛出原始异常：

public void read(String filename) throws BaseException {    
        FileInputStream input = null;    
        IOException readException = null;    
        try {    
            input = new FileInputStream(filename);    
        } catch (IOException ex) {    
            readException = ex;   //保存原始异常    
        } finally {    
            if (input != null) {    
                try {    
                    input.close();    
                } catch (IOException ex) {    
                    if (readException == null) {    
                        readException = ex;    
                    }    
                }    
            }    
            if (readException != null) {    
                throw new BaseException(readException);    
            }    
        }    
    }    

在Java7中的版本，可以使用addSuppressed方法记录被抑制的异常：

 public void read(String filename) throws IOException {    
        FileInputStream input = null;    
        IOException readException = null;    
        try {    
            input = new FileInputStream(filename);    
        } catch (IOException ex) {    
            readException = ex;    
        } finally {    
            if (input != null) {    
                try {    
                    input.close();    
                } catch (IOException ex) {    
                    if (readException != null) {    //此处的区别    
                        readException.addSuppressed(ex);    
                    }    
                    else {    
                        readException = ex;    
                    }    
                }    
            }    
            if (readException != null) {    
                throw readException;    
            }    
        }    
    } 

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

try子句中可以管理多个资源：

public void copyFile(String fromPath, String toPath) throws IOException {    
     try ( InputStream input = new FileInputStream(fromPath);    
    OutputStream output = new FileOutputStream(toPath) ) {    
         byte[] buffer = new byte[8192];    
int len = -1;    
while( (len=input.read(buffer))!=-1 ) {    
    output.write(buffer, 0, len);    
}    
     }     
 }  

4、创建泛型时类型推断

只要编译器可以从上下文中推断出类型参数，你就可以用一对空着的尖括号<>来代替泛型参数。这对括号私下被称为菱形(diamond)。 在Java SE 7之前，你声明泛型对象时要这样
    List<String> list = new ArrayList<String>(); 
    而在Java SE7以后，你可以这样 
    List<String> list = new ArrayList<>(); 
    因为编译器可以从前面(List)推断出推断出类型参数，所以后面的ArrayList之后可以不用写泛型参数了，只用一对空着的尖括号就行。当然，你必须带着”菱形”<>，否则会有警告的。 
    Java SE7 只支持有限的类型推断：只有构造器的参数化类型在上下文中被显著的声明了，你才可以使用类型推断，否则不行。 
    List<String> list = new ArrayList<>(); 
    list.add("A"); 
    //这个不行 
    list.addAll(new ArrayList<>()); 
    // 这个可以 
    List<? extends String> list2 = new ArrayList<>(); 
    list.addAll(list2);

5、全新的集合声明以及获取集合中的值的方式

JDK1.7以前声明集合的方式
    List<String> strs  = new ArrayList<String>();
    Map<String,String> map = new HashMap<String,String>();
    strs.add("abc");
    strs.get(index);
    map.put("key","全新集合");
    map.get(key);

    JDK1.7以后
    List<String> list = [item1,item2,item3];
    String item1 = list[0];
    String item2 = list[1];
    String item3 = list[2];
    Map<String,String> map = {key:value,key:value}
    String mapValue = map[key];

6、两个char间的equals

boolean Character.equalsIgnoreCase(char ch1,char ch2) 

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