Java 7语法新特性

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接: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<>();

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

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

 

展开阅读全文

没有更多推荐了,返回首页