发表更新Java27 分钟读完 (大约3991个字)

12种Java中常用的语法糖

什么是语法糖

语法糖（Syntactic Sugar），也称糖衣语法，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。

解语法糖

前面提到过，语法糖的存在主要是方便开发人员使用。但其实，Java虚拟机并不支持这些语法糖。这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖。说到编译，大家肯定都知道，Java语言中，javac命令可以将后缀名为.java的源文件编译为后缀名为.class的可以运行于Java虚拟机的字节码。如果你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发现在compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。Java 中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。

糖块一： switch 支持 String 与枚举

从Java 7 开始，switch 开始支持 String。其实Java中的switch自身原本就支持基本类型。比如int、char等。对于int类型，直接进行数值的比较。对于char类型则是比较其 ascii 码。

所以，对于编译器来说，switch中其实只能使用整型，任何类型的比较都要转换成整型。比如byte。short，char(ascii码是整型)以及int。

那么接下来看下 switch 对 String 的支持，有以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class SwitchTest {
    public static void main(String[] args) {
        String s = "Shuke";
        switch (s) {
            case "Shuke":
                System.out.println("Shuke");
                break;
            case "Bata":
                System.out.println("Bata");
                break;
            default:
                break;
        }
    }
}

反编译后的内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class SwitchTest {
    public SwitchTest() {
    }

    public static void main(String[] args) {
        String s = "Shuke";
        byte var3 = -1;
        switch(s.hashCode()) {
        case 2063116:
            if (s.equals("Bata")) {
                var3 = 1;
            }
            break;
        case 79866362:
            if (s.equals("Shuke")) {
                var3 = 0;
            }
        }

        switch(var3) {
        case 0:
            System.out.println("Shuke");
            break;
        case 1:
            System.out.println("Bata");
        }

    }
}

可以发现字符串的switch是通过equals()和hashCode()方法来实现的，hashCode()方法返回的是int，而不是long。

进行switch的实际是哈希值，然后通过使用equals方法比较进行安全检查，这个检查是必要的，因为哈希可能会发生碰撞。

糖块二： 泛型

很多语言都是支持泛型的，但不同的编译器对于泛型的处理方式是不同的。

通常情况下，一个编译器处理泛型有两种方式：Code specialization和Code sharing。

C++和C#是使用Code specialization的处理机制，而Java使用的是Code sharing的机制。

Code sharing方式为每个泛型类型创建唯一的字节码表示，并且将该泛型类型的实例都映射到这个唯一的字节码表示上。将多种泛型类形实例映射到唯一的字节码表示是通过类型擦除（type erasue）实现的。

也就是说，对于Java虚拟机来说，它根本不认识 Map<String, String> map 这样的语法。需要在编译阶段通过类型擦除的方式进行解语法糖。

类型擦除的主要过程如下：

  1. 将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。

  2. 移除所有的类型参数。

  • 例如:

    1
    2
    3
    4
    Map<String, String> map = new HashMap<String, String>();
    map.put("111", "222");
    map.put("333", "444");
    map.put("555", "666");

    解语法糖后：

    1
    2
    3
    4
    Map map = new HashMap();
    map.put("111", "222");
    map.put("333", "444");
    map.put("555", "666");

虚拟机中没有泛型，只有普通类和普通方法，所有泛型类的类型参数在编译时都会被擦除，并没有自己独有的 Class 类对象。比如并不存在 List<String>.class 或是List<Integer>.class，而只有 List.class。

补充：

  1. 当泛型遇到重载
1
2
3
4
5
6
7
8
  public class GenericTypes {
    public static void method(List<String> list) {
        System.out.println("invoke method(List<String> list)");
    }
    public static void method(List<Integer> list) {
        System.out.println("invoke method(List<Integer> list)");
    }
}

上面这段代码，有两个重载的函数，因为他们的参数类型不同，但是，这段代码是编译不通过的。因为参数 List 和 List 编译之后都被擦除了，变成了一样的原生类型 List，擦除动作导致这两个方法的特征签名变得一模一样。

  1. 当泛型遇到catch

泛型的类型参数不能用在 Java 异常处理的 catch 语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除，JVM是无法区分两个异常类型 MyException<String> 和 MyException<Integer> 的。

  1. 当泛型内包含静态变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class StaticTest {
    public static void main(String[] args) {
        GT<Integer> gti = new GT<Integer>();
        gti.var = 1;
        GT<String> gts = new GT<String>();
        gts.var = 2;
        System.out.println(gti.var);
    }
}

class GT<T> {
    public static int var = 0;

    public void nothing(T x) {
    }
}

以上代码输出结果为：2 !!! 由于经过类型擦除，所有的泛型类实例都关联到同一份字节码上，泛型类的所有静态变量是共享的。

糖块三： 自动装箱与拆箱

自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。

因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。

原始类型byte, short, char, int, long, float, double 和 boolean 对应的封装类为Byte, Short, Character, Integer, Long, Float, Double, Boolean。

先来看个自动装箱的代码：

1
2
3
4
public static void main(String[] args) {
    int i = 10;
    Integer n = i;
}

反编译后代码如下:

1
2
3
4
5
public static void main(String args[])
{
    int i = 10;
    Integer n = Integer.valueOf(i);
}

再来看个自动拆箱的代码：

1
2
3
4
public static void main(String[] args) {
    Integer i = 10;
    int n = i;
}

反编译后代码如下：

1
2
3
4
5
public static void main(String args[])
{
    Integer i = Integer.valueOf(10);
    int n = i.intValue();
}

从反编译得到内容可以看出，装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。

补充：

自动装箱与拆箱——对象相等比较：

1
2
3
4
5
6
7
8
public static void main(String[] args) {
    Integer a = 1000;
    Integer b = 1000;
    Integer c = 100;
    Integer d = 100;
    System.out.println("a == b is " + (a == b));
    System.out.println(("c == d is " + (c == d)));
}

在Java 5中，在Integer的操作上引入了一个新功能来节省内存和提高性能。整型对象通过使用相同的对象引用实现了缓存和重用。适用于整数值区间-128 至 +127。只适用于自动装箱。使用构造函数创建对象不适用。数据会被自动装箱成包装类，JVM在比较之前会看在不在常量池范围内，在就字面量比较，不在就比较地址值。

糖块四： 方法变长参数

可变参数(variable arguments)是在Java 1.5中引入的一个特性。它允许一个方法把任意数量的值作为参数。

看下以下可变参数代码，其中print方法接收可变参数：

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args)
{
    print("111", "222", "333", "444");
}
public static void print(String... strs)
{
    for (int i = 0; i < strs.length; i++)
    {
        System.out.println(strs[i]);
    }
}

反编译后得到：

1
2
3
4
5
6
7
8
9
10
11
public static void main(String args[])
{
    print(new String[] {
    "111", "222", "333", "444"
    });
}
public static transient void print(String strs[])
{
    for(int i = 0; i < strs.length; i++)
    System.out.println(strs[i]);
}

从反编译后代码可以看出，可变参数在被使用的时候，他首先会创建一个数组，数组的长度就是调用该方法是传递的实参的个数，然后再把参数值全部放到这个数组当中，然后再把这个数组作为参数传递到被调用的方法中。

糖块五： 枚举

Java SE5 提供了一种新的类型 — Java的枚举类型，关键字enum可以将一组具名的值的有限集合创建为一种新的类型，而这些具名的值可以作为常规的程序组件使用，这是一种非常有用的功能。enumn就和 class 一样，只是一个关键字，并不是一个类。

1
2
3
public enum t {
        SPRING,SUMMER;
}

反编译后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public final class T extends Enum
{
     private T(String s, int i)
     {
        super(s, i);
     }
     public static T[] values()
     {
        T at[];
        int i;
        T at1[];
        System.arraycopy(at = ENUM$VALUES, 0, at1 = new T[i = at.length], 0, i);
        return at1;
     }
     public static T valueOf(String s)
     {
        return (T)Enum.valueOf(demo/T, s);
     }
     public static final T SPRING;
     public static final T SUMMER;
     private static final T ENUM$VALUES[];
     static
     {
        SPRING = new T("SPRING", 0);
        SUMMER = new T("SUMMER", 1);
        ENUM$VALUES = (new T[] {
        SPRING, SUMMER
     });
     }
}

public final class T extends Enum 说明该类是继承了Enum类的，同时final关键字意味着这个类也是不能被继承的。

当我们使用enmu来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承。

糖块六： 内部类

内部类又称为嵌套类，可以把内部类理解为外部类的一个普通成员。内部类之所以也是语法糖，是因为它仅仅是一个编译时的概念。

比如在 A.java 里面定义了一个内部类 B，一旦编译成功，就会生成两个完全不同的.class文件，分别是 A.class 和 A$B.class。所以内部类的名字完全可以和它的外部类名字相同。

一个类对应一个.class文件，多个类嵌套就会有多个.class文件。

糖块七：条件编译

一般情况下，程序中的每一行代码都要参加编译。但有时候出于对程序代码优化的考虑，希望只对其中一部分内容进行编译，此时就需要在程序中加上条件，让编译器只对满足条件的代码进行编译，将不满足条件的代码舍弃，这就是条件编译。

1
2
3
4
5
6
7
8
9
10
11
12
public class ConditionalCompilation {
    public static void main(String[] args) {
        final boolean DEBUG = true;
        if(DEBUG) {
            System.out.println("Hello, DEBUG!");
        }
        final boolean ONLINE = false;
        if(ONLINE){
            System.out.println("Hello, ONLINE!");
        }
    }
}

反编译后代码如下：

1
2
3
4
5
6
7
8
9
10
public class ConditionalCompilation {
    public ConditionalCompilation() {
    }

    public static void main(String[] args) {
        boolean DEBUG = true;
        System.out.println("Hello, DEBUG!");
        boolean ONLINE = false;
    }
}

首先，我们发现，在反编译后的代码中没有 System.out.println(“Hello, ONLINE!”);，这其实就是条件编译。当 if(ONLINE) 为 false 的时候，编译器就没有对其内的代码进行编译。

所以，Java语法的条件编译，是通过判断条件为常量的 if 语句实现的。根据 if 判断条件的真假，编译器直接把分支为 false 的代码块消除。通过该方式实现的条件编译，必须在方法体内实现，而无法在正整个Java类的结构或者类的属性上进行条件编译。

糖块八： 断言

在Java中，assert关键字是从JAVA SE 1.4 引入的，为了避免和老版本的Java代码中使用了assert关键字导致错误，Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都将忽略！）。如果要开启断言检查，则需要用开关 -enableassertions 或 -ea来开启。

assert关键字语法很简单，有两种用法：

  1. assert boolean表达式

    如果为true，则程序继续执行。

    如果为false，则程序抛出AssertionError，并终止执行。

  2. assert boolean表达式 : 错误信息表达式

    如果为true，则程序继续执行。

    如果为false，则程序抛出java.lang.AssertionError，并输入\<错误信息表达式>。

例：

1
2
3
4
5
6
7
8
9
10
11
public class AssertFoo {
    public static void main(String args[]) {
        //断言1结果为true，则继续往下执行
        assert true;
        System.out.println("断言1没有问题，Go！");
        System.out.println("\n-----------------\n");
        //断言2结果为false,程序终止
        assert false : "断言失败，此表达式的信息将会在抛出异常的时候输出！";
        System.out.println("断言2没有问题，Go！");
    }
}

开启-ea开关，执行程序：

1
2
3
4
5
C:\>java -ea AssertFoo

断言1没有问题，Go！
-----------------
Exception in thread "main" java.lang.AssertionError: 断言失败，此表达式的信息将会在抛出异常的时候输出！at AssertFoo.main(AssertFoo.java:10)

其实断言的底层实现就是 if 语言，如果断言结果为 true，则什么都不做，程序继续执行，如果断言结果为 false，则程序抛出 AssertionError 来打断程序的执行。

糖块十： for-each

1
2
3
4
5
6
7
8
public class ForEachTest {
    public static void main(String... args) {
        String[] strs = {"111", "222", "333"};
        for (String s : strs) {
            System.out.println(s);
        }
    }
}

反编译后代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ForEachTest {
    public ForEachTest() {
    }

    public static void main(String... args) {
        String[] strs = new String[]{"111", "222", "333"};
        String[] var2 = strs;
        int var3 = strs.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String s = var2[var4];
            System.out.println(s);
        }

    }
}

for-each 的实现原理其实就是使用了普通的 for 循环和迭代器。

补充：

1
2
3
4
for (Student stu : students) { 
    if (stu.getId() == 2) 
    students.remove(stu); 
}

会抛出ConcurrentModificationException异常。

Iterator是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。

所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法remove()来删除对象，Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

糖块十一： try-with-resource

Java里，对于文件操作IO流、数据库连接等开销非常昂贵的资源，用完之后必须及时通过close方法将其关闭，否则资源会一直处于打开状态，可能会导致内存泄露等问题。

关闭资源的常用方式就是在 finally 块里是释放，即调用 close 方法。比如，我们经常会写这样的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
    BufferedReader br = null;
    try {
        String line;
        br = new BufferedReader(new FileReader("xxx"));
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        // handle exception
    } finally {
        try {
            if (br != null) {
                br.close();
            }
        } catch (IOException ex) {
            // handle exception
        }
    }
}

从Java 7开始，jdk 提供了一种更好的方式关闭资源，使用 try-with-resources 语句，改写一下上面的代码，效果如下：

1
2
3
4
5
6
7
8
9
10
public static void main(String... args) {
    try (BufferedReader br = new BufferedReader(new FileReader("xxx")))            {
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        // handle exception
    }
}

其实背后的原理也很简单，那些我们没有做的关闭资源的操作，编译器都帮我们做了。

糖块十二： Lambda表达式

Labmda 表达式不是匿名内部类的语法糖，但是他也是一个语法糖。实现方式其实是依赖了几个 JVM 底层提供的 lambda 相关 api。

它并不是内部类的语法糖，前面讲内部类我们说过，内部类在编译之后会有对应的 class 文件，但是，包含 lambda 表达式的类编译后只有一个文件。

12种Java中常用的语法糖

https://www.benboby.top/2020/09/12%E7%A7%8DJava%E4%B8%AD%E5%B8%B8%E7%94%A8%E7%9A%84%E8%AF%AD%E6%B3%95%E7%B3%96.html

作者

Benboby

发布于

2020-09-01

更新于

2021-02-03

许可协议

#

链接

分类

最新文章

归档

标签

C++内存管理1
C++基础3
C++面向对象3
DFS1
JVM3
Java反射1
Java基础2
Java多线程1
Makefile1
MySQL1
RMQ1
STL7
Vim1
二分2
动态规划14
区间dp3
博弈论1
回文1
图论2
多校训练3
字典树1
并查集4
思维15
操作系统2
数学7
最小生成树1
树2
树形dp2
树状数组5
状压dp3
线性dp1
网络编程1
背包dp2
计数dp5
计算机网络1
记忆化搜索2
设计模式2
贪心10
Your browser is out-of-date!

Update your browser to view this website correctly.&npsb;Update my browser now

×

×