Java 7语法新特性

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u012152619/article/details/72236577

1、switch 语句支持字符串

switch语句是一种高效的多路语句，可以省掉很多繁杂的嵌套if判断，比如：

public void printDay(int dayOfWeek) {
      switch (dayOfWeek) {
      case 0:
             System.out.println("星期日");
             break;
      case 1:
             System.out.println("星期一");
             break;
      case 2:
             System.out.println("星期二");
             break;
      case 3:
             System.out.println("星期三");
             break;
      case 4:
             System.out.println("星期四");
             break;
      case 5:
             System.out.println("星期五");
             break;
      case 6:
             System.out.println("星期六");
             break;
      }
}

在Java 7以前，case语句中的常量只能是byte、short、int、char（以及他们的包装类）或枚举常量。Java 7中增加了对String的支持，大快人心。比如可以这样写：

public void printDay(String day) {
      switch (day) {
      case "Sunday":
             System.out.println("星期日");
             break;
      case "Monday":
             System.out.println("星期一");
             break;
      case "Tuesday":
             System.out.println("星期二");
             break;
      case "Wednesday":
             System.out.println("星期三");
             break;
      case "Thursday":
             System.out.println("星期四");
             break;
      case "Friday":
             System.out.println("星期五");
             break;
      case "Saturday":
             System.out.println("星期六");
             break;
      }
}

2、更强的数字文本表示法

在Java 7之前，如果要处理二进制值，必须借助棘手的基础转换，或者调用parseX方法。比如说，想让int x用位模式表示十进制102，可以这么写：

int x = Integer.parseInt("1100110", 2);

这种方法尽管看起来还行，但实际上存在很多问题，比如，二进制字符串的拼写错误无法在编译阶段检出，会在运行时抛出RuntimeException。

Java支持八进制、十六进制的文本表示，单独把二进制拒之门外，显然太不合情理。Java 7中，二进制拥有了跟八进制、十六进制类似的表示方法：

      public static void main(String[] args) {
             int binary = 0b1111;  //二进制，以'0b'开头，Java 7 新增特性
             int octal = 01111;  //八进制，以'0'开头
             int hexadecimal = 0x1111;  //十六进制，以'0x'开头
            
             System.out.println("binary'1111': " + binary);  //十进制15
             System.out.println("octal'1111': " + octal);  //十进制585
             System.out.println("hexadecimal'1111': " + hexadecimal);  //十进制4369
      }

跟二进制打交道时，这个小特性会是你的得力助手。

众所周知，人脑跟电脑有很多不同的地方，对于数字的处理方式就是其中之一。通常人们不太喜欢面对一大串数字。这也是我们发明十进制的原因之一——人脑更善于处理信息量大而长度短的字符串。也就是说，我们觉得十进制“1234”比等值的二进制“10011010010”更容易处理，但是，电脑只认第二种。人们在处理长串数字时会采用分隔法，比如用400-135-6789表示电话号码，用100 000 000美元表示金钱数额。

Java 7中借用Ruby的创意，用下划线作为分隔符。注意，这只是为了让你阅读数字时更易理解而做的一个小修改，编译器会在编译时把下划线去掉。

比如：

int bitPattern =0b0001_1100_0111_0010_1010_0011;

分隔之后，看起来是清爽多了。

3、改善后的异常处理

Java的异常处理一直饱受诟病，臃肿繁复，事倍功半。其中的数据库的检查异常让人印象深刻，try-catch简直让人抓狂。

来看一个文件操作的例子：

public void sample(String url) {
    File file = new File(url);
    Reader in = null;
    BufferedReader reader = null;
    try {
        in = new FileReader(file);
        reader = new BufferedReader(in);
        String line;
        while ((line = reader.readLine()) != null) {
            doSomething(line);
        }
    } catch (ClassNotFoundException e) {
        System.out.println("ClassNotFoundException interrupted");
    } catch (XMLParseException e) {
        System.out.println("XMLParseException interrupted");
    } catch (IOException e) {
        System.out.println("IOException interrupted");
    } finally {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (in != null) {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

private void doSomething(String line) throws XMLParseException, ClassNotFoundException {
    // TODO Auto-generated method stub
}

上例中，为要获取文件内容，需要处理三种受检异常，关闭两种资源流。大部分try-catch代码都是与具体业务无关的。

在Java 7中可以这么做，XMLParseException、ClassNotFoundException、IOException都是与文件相关的异常，可归为一类集中处理

......           
} catch(ClassNotFoundException | XMLParseException | IOException e) {
        System.out.println("file errorinterrupted");
    }
......

虽然没有什么太大的改观，但是好歹比之前的代码简约一点点。Java 7中的另一个新特性——try-with-resources语句带来的简化就不是“一点点”了，而是“大刀阔斧”。

上例中，两种资源Reader及BufferedReader在finally语句中需要先判空，再关闭，而且关闭的时候还要再用try-catch包裹！what a fucking code !

在Java 7中，可以这么写：

public void sample(String url) {
    File file = new File(url);
    try (Reader in = new FileReader(file); // 将资源流放在try后面的括号内，系统会自动关闭它们
         BufferedReader reader = new BufferedReader(in);) { 
        String line;
        while ((line = reader.readLine()) != null) {
            doSomething(line);
        }
    } catch (ClassNotFoundException | XMLParseException | IOException e) {
        System.out.println("file errorinterrupted");
    }
}

世界终于清静了。

需要注意的是，括号内的资源流最好使用单独变量，不要这么写：

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

有可能造成try-with-resources语句失效。

Java 7中增加了一个名为AutoCloseable的接口，try-with-resources语句中出现的资源类都必须实现这个接口。Java 7中的大多数资源类都被修修改过，已经实现了该接口。

4、钻石语法

Java 另一个被很多人抱怨的地方是泛型，举个很简单的例子，用嵌套的两层Map对下面的数据结构建模：

<班级编号，<学号, 姓名>>

Map<Long,Map<Long, String>> studentsMap = new HashMap<Long, Map<Long,String>>();

代码太长，而且有近一半的代码都是重复的。右侧的类型信息如果让编译自动推断出来岂不快哉？Java 7就可以任性地这么写：

Map<Long,Map<Long, String>> studentsMap = new HashMap<>();

编译器采用了新的类型推断形式，会根据依据右侧的“<>”标志准确地推断出正确的泛型信息。

因为“<>”符号比较像钻石（外国人想象力真丰富），就称为“钻石语法”。