「JVM 编译优化」Java 语法糖（泛型、自动装箱/拆箱、条件编译）

「JVM 编译优化」Java 语法糖（泛型、自动装箱/拆箱、条件编译）

语法糖可以看做事前端编译期的一些小把戏；虽不会提供实质性的功能改进，但它们或能提高效率，或能提升语法的严谨性，或能减少编码出错的机会；不过语法糖也并不一定都是有益的，大量添加和使用含糖的语法，容易让程序员产生依赖，无法看清语法糖背后代码的真实面目（编译层面）；

Java 的语法糖有泛型、自动装箱、自动拆箱、遍历循环、变长参数、条件编译、内部类、枚举类、断言语句、数值字面量、对枚举和字符串的 switch 支持、try-resource（JDK 7）、Lambda 表达式（JDK 8，不算单纯的语法糖，但前端编译器做了大量转换工作）等；

要了解小把戏背后的真实实现，才能最好的利用好它；

1. 泛型

泛型本质是参数化类型（Parameterized Type）或参数化多态（Parametric Polymorphism）的应用，对泛化的数据类型编写相同的算法（抽象）；将操作的数据类型指定为方法签名中的一种特殊参数，参数类型可用在类、接口、方法的创建中分别构造泛型类、泛型接口、泛型方法；

Java 泛型 vs. C# 泛型

• 类型擦除式泛型（Type Erasure Generics），Java 的实现方式，泛型只存在于程序源码，在编译后的字节码中所有泛型都变成原裸那类型（Raw Type），并插入相应的强制转型代码；在运行期的 ArrayList<Int> 和 ArrayList<String> 是同一种类型；
• 具现化式泛型（Reified Generics），C# 的实现方式，泛型在程序源码、编译后的中间语言表示（Intermediate Language，泛型是一个占位符）、运行期的 CLR 里都是切实存在的；在运行期的 List<Int> 和 List<String> 是两种不同类型，它们由系统在运行期生成；

Java 不合法的泛型用法

public class TypeErasureGenerics<E> {
    public void doSomething(Object item) {
        if (item instanceof E) {    // 不合法，无法对泛型进行实例判断；
            // ...
        }
        E newItem = new E();        // 不合法，无法使用泛型创建对象；
        E[] itemArray = new E[10];  // 不合法，无法使用泛型创建数组；
    }
}

相比 C# 的泛型，除了使用层面上需要更多代码、更多类型参数来编写使用；Java 的泛型在执行性能方面是难以用应用编码弥补的（需要大量拆箱装箱、构造容器，引入复杂度高的代码，降低了复用性，几乎丧失了泛型本身存在的价值）；

Java 的泛型实现只需在 javac 编译器上做出改进，不需要改动字节码、JVM，保障了以前无泛型的库直接运行在新版 JDK 环境；

泛型的历史背景

《Java 语言规范》严肃承诺二进制向后兼容（Binary Backwards Compatibility）；

// 协变（Covariant）演示
Object[] array = new String[10];
array[0] = 10;                      // 编译正常、运行报错；

ArrayList things = new ArrayList();
things.add(Integer.valueOf(10));    // 编译、运行皆正常；
things.add("hello world");

• （C# 版）需要泛型化的类型（容器类型），以前有的保持不变，并平行添加一套泛型化版本的新类型；C# 新增一组 System.Collections.Generic 容器，原 System.Collections 和 System.Collection.Specialized 容器依旧存在；
• （Java 版）直接把所有需要泛型化的已有类型原地泛型化，不添加任何平行泛型版本；Java 也尝试了引入新的集合类，但因遗留代码规模和流行度较大、设计实现时间不足等原因，最终选择了类型擦除式实现；

类型擦除

• 裸类型（Raw Type），所有该类型泛型化的共同父类型（Super Type）；

ArrayList<Integer> ilist = new ArrayList<Integer>();
ArrayList<String> slist = new ArrayList<String>();
ArrayList list;     // 裸类型
list = ilist；
list = slist;

• 在运行期由 JVM 自动真实的构造 ArrayList 的类型，病自动实现从 ArrayList 派生自 ArrayList 的继承关系；
• 在编译期把 ArrayList 还原会 ArrayList，只在元素反问、修改时自动插入一些类型强转和检查的指令；

泛型擦除示例

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();
    map.put("hello", "你好");
    map.put("how are you?", "吃了吗？");
    System.out.println(map.get("hello"));
    System.out.println(map.get("how are you?"));
}

擦除后（编译后）的效果

public static void main(String[] args) {
    Map map = new HashMap();
    map.put("hello", "你好");
    map.put("how are you?", "吃了吗？");
    System.out.println((String) map.get("hello"));
    System.out.println((String) map.get("how are you?"));
}

擦除法的缺陷

• 使用擦除法实现泛型时原始类型（Primitive Type）数据的支持很麻烦，因为基础类型与 Object 之间无法强转；因此 Java 的泛型直接不支持原始类型；
• 运行期无法取到泛型类型信息；如需知道泛型类型信息，需额外通过 Class<T> 类型的参数传递进来；
• 擦除发实现泛型导致一些面向对象思想变得模糊；

// 重载 1，无法编译通过；编译后的裸类型相同；
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)");
    }
}

// 重载 2，可以编译通过；Class 文件允许描述符不完全一致的两个方法共存；
public class GenericTypes {
    public static String method(List<String> list) {
        System.out.println("invoke method(List<String> list)");
        return "";
    }

    public static int void method(List<Integer> list) {
        System.out.println("invoke method(List<Integer> list)");
        return 1;
    }

Java 泛型的引入在 JVM 解析、反射等场景下的方法调用带来了新的需求，如泛型类中获取传入的参数化类型等；JCP 为此引入了诸如 Signature、LocalVariableTypeTable 等新的属性用于解决伴随泛型而来的参数类型识别问题；
擦除法实际仅仅对方法的 Code 属性中字节码进行了擦除，元数据中还是保留着泛型信息，反射手段是可以取到参数化类型的；

值类型与未来的泛型

Oracle 在 2014 年建立了 Valhalla 语言改进项目，用于改进 Java 语言中各种缺陷（泛型的缺陷是主要目标之一）；

Valhalla 对新泛型实现规划了多种方案，如 Model 1 和 Model 3；其中泛型可能被具现化，也可能继续维持类型擦除（不完全擦除）以保兼容性；

目前比较明确的是未来 Java 会提供值类型（Value Type）的语言层面支持；值类型可以与引用类型一样具有构造函数、方法、属性字段等，区别在于它的赋值通常是整体赋值，而不像引用类型的传递引用；这样值类型实例更容易实现在调用栈上分配，可以随着退出方法自动回收，从而减轻 GC 压力；

Valhalla 中的值类型方案被称为内联类型，通过一个新的关键字 inline 来定义，字节码层面则以与原生类型对应的 Q 开头的新操作码（如 iload 对应 qload）来支撑；

即时编译场景下，可以使用逃逸分析优化来处理内联类型；通过编码时标注和内联类型实例的不可变性，可以很好的解决逃逸分析面对传统引用类型时难以判断对象是否逃逸的问题；

2. 自动装箱、拆箱、遍历循环

自动装箱、自动拆箱、循环遍历（for-each 循环）等语法糖是 Java 中被使用最多的语法糖；

自动装箱、自动拆箱、循环遍历演示

public static void main(String[] args) {
    List<String> list = Arrays.asList(1, 2, 3, 4;
    int sum = 0;
    for (int i : list) {
        sum += i;
    }
    System.out.println(sum);
}

编译后的效果

public static void main(String[] args) {
    // 1. 泛型被擦除；
    // 2. 自动装箱、拆箱被转化成对应的包装盒还原方法；
    // 3. 变长参数变成数组类型的参数；
    List list = Arrays.asList(new Integer[] {
        Integer.valueOf(1),
        Integer.valueOf(2),
        Integer.valueOf(3),
        Integer.valueOf(4)
    });

    int sum = 0;
    // 4. 循环遍历被还原成了迭代器的实现；这是遍历循环中被遍历的实力类需要实现 Iterable 接口的原因；
    for (Iterator localIterator = list.iterator(); localItertor.hasNext(); ) {
        int i = ((Integer) localIterator.next()).intValue();
        sum += i;
    }
    System.out.println(sum);
}

自动装箱的陷阱

public static void main(String[] args) {
    Integer a = 1;
    Integer b = 2;
    Integer c = 3;
    Integer d = 3;
    Integer e = 321;
    Integer f = 321;
    Long g = 3L;
    System.out.println(c == d);             // true，Integer 的享元模式实现方式让 -128 ~ 127 之间的实例复用；
    System.out.println(e == f);             // false，不在 Integer 享元范围，不是共享；
    System.out.println(c == (a + b));       // true，== 运算在遇到算术运算时自动拆箱；
    System.out.println(c.equals(a + b));    // true，类型与值皆相同
    System.out.println(g == (a + b));       // true，== 运算在遇到算术运算时自动拆箱；
    System.out.println(g.equals(a + b));    // false，值相同，但类型不同，equals() 方法不处理数据转型；
}

建议在实际编码中尽量避免自动装箱与拆箱；

3. 条件编译

Java 语言天然的编译方式不需使用预处理器（编译器并非一个个编译 Java 文件，而是通过编译单元构建语法树顶级节点待处理列表，再行编译，各个文件可以相互提供符号信息）；

Java 语言的条件编译以使用条件为常量的 if 语句实现；跟进 boolean 值真假，编译器会将不成立的分支代码消除掉（编译器的解语法糖阶段完成）；只支持方法体内部的语句基本块（Block）级别的条件编译，不支持整个 Java 类的控制；

public static void main(String[] args) { 
    if (true) {
        System.out.println("block 1"); 
    } else {
        System.out.println("block 2"); 
    }
}

编译后的效果

public static void main(String[] args) { 
    // 编译出来的结果只会保留 true 的分支
    System.out.println("block 1");
}

若其他带有条件判断能力的控制语句与常量搭配使用，可能会被拒绝编译；

public static void main(String[] args) { 
    // 编译器将会提示“Unreachable code” 
    while (false) {
        System.out.println(""); 
    }
}

---

上一篇：「JVM 编译优化」javac 编译器源码解读
下一篇：「JVM 编译优化」插入式注解处理器（自定义代码编译检查）

PS：感谢每一位志同道合者的阅读，欢迎关注、评论、赞！

---

参考资料：

• [1]《深入理解 Java 虚拟机》