Java7语法新特性

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

Java代码

1. public String generate(String name, String gender) {  
2.    String title = "";  
3.    switch (gender) {  
4.        case "男":  
5.            title = name + " 先生";  
6.            break;  
7.        case "女":  
8.            title = name + " 女士";  
9.            break;  
10.        default:  
11.            title = name;  
12.    }  
13.    return title;  

     public String generate(String name, Stringgender) {

        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以前版本。

2. 数字字面量的改进
①增加二进制表示
Java7前支持十进制（123）、八进制（0123）、十六进制（0X12AB）
Java7增加二进制表示（0B11110001、0b11110001）
②数字中可添加分隔符
Java7中支持在数字量中间增加'_'作为分隔符，更直观，如（12_123_456），下划线只能在数字中间，编译时编译器自动删除数字中的下划线。

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

Java代码

1. public void read(String filename) throws BaseException {  
2.     FileInputStream input = null;  
3.     IOException readException = null;  
4.     try {  
5.         input = new FileInputStream(filename);  
6.     } catch (IOException ex) {  
7.         readException = ex;   //保存原始异常  
8.     } finally {  
9.         if (input != null) {  
10.             try {  
11.                 input.close();  
12.             } catch (IOException ex) {  
13.                 if (readException == null) {  
14.                     readException = ex;  
15.                 }  
16.             }  
17.         }  
18.         if (readException != null) {  
19.             throw new BaseException(readException);  
20.         }  
21.     }  
22. }  

    public void read(String filename) throwsBaseException {

        FileInputStream input = null;

        IOException readException = null;

        try {

            input = newFileInputStream(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方法记录被抑制的异常：

Java代码

1. public void read(String filename) throws IOException {  
2.     FileInputStream input = null;  
3.     IOException readException = null;  
4.     try {  
5.         input = new FileInputStream(filename);  
6.     } catch (IOException ex) {  
7.         readException = ex;  
8.     } finally {  
9.         if (input != null) {  
10.             try {  
11.                 input.close();  
12.             } catch (IOException ex) {  
13.                 if (readException != null) {    //此处的区别  
14.                     readException.addSuppressed(ex);  
15.                 }  
16.                 else {  
17.                     readException = ex;  
18.                 }  
19.             }  
20.         }  
21.         if (readException != null) {  
22.             throw readException;  
23.         }  
24.     }  
25. }  

    public void read(String filename) throwsIOException {

        FileInputStream input = null;

        IOException readException = null;

        try {

            input = newFileInputStream(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子句可以同时捕获多个异常

Java代码

1. public void testSequence() {  
2.     try {  
3.         Integer.parseInt("Hello");  
4.     }  
5.     catch (NumberFormatException | RuntimeException e) {  //使用'|'分割，多个类型，一个对象e  
6.          
7.     }  
8. }  

    public void testSequence() {

        try {

           Integer.parseInt("Hello");

        }

        catch (NumberFormatException |RuntimeException e) {  //使用'|'分割，多个类型，一个对象e

          

        }

    }

③try-with-resources语句
Java7之前需要在finally中关闭socket、文件、数据库连接等资源；
Java7中在try语句中申请资源，实现资源的自动释放（资源类必须实现java.lang.AutoCloseable接口，一般的文件、数据库连接等均已实现该接口，close方法将被自动调用）。

Java代码

1.  public void read(String filename) throws IOException {  
2.      try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {  
3.          StringBuilder builder = new StringBuilder();  
4. String line = null;  
5. while((line=reader.readLine())!=null){  
6.     builder.append(line);  
7.     builder.append(String.format("%n"));  
8. }  
9. return builder.toString();  
10.      }   
11.  }  

    public void read(String filename) throwsIOException {

        try (BufferedReader reader = newBufferedReader(new FileReader(filename))) {

            StringBuilder builder = newStringBuilder();

     String line = null;

     while((line=reader.readLine())!=null){

      builder.append(line);

      builder.append(String.format("%n"));

     }

     return builder.toString();

        }

    }

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

Java代码

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

    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. 变长参数方法的优化
Java7之前版本中的变长参数方法：

Java代码

1. public int sum(int... args) {  
2.     int result = 0;  
3.     for (int value : args) {  
4.         result += value;  
5.     }  
6.     return result;  
7. }  

    public int sum(int... args) {

        int result = 0;

        for (int value : args) {

            result += value;

        }

        return result;

    }

当参数为不可具体化的类型时，如List，编译器将产生警告，需要使用@SuppressWarnings("unchecked")注解声明；Java7中使用@SafeVarargs注解抑制编译器警告。

Java代码

1. @SafeVarargs  
2. public static <T> T useVarargs(T... args) {  
3.     return args.length > 0 ? args[0] : null;  
4. }  

    @SafeVarargs

    public static <T> T useVarargs(T...args) {

        return args.length > 0 ? args[0] :null;

    }

 

Java代码

1. VarargsWarning.useVarargs(new ArrayList<String>());  

VarargsWarning.useVarargs(newArrayList<String>());

 

本文转载自http://uuhorse.iteye.com/blog/1704118