JVM-Java语法糖与Java编译器

　　基本类型和其包装类型之间的自动转换，也就是自动装箱、自动拆箱，是通过加入[Wrapper].valueOf（如 Integer.valueOf）以及[Wrapper].[primitive]Value（如 Integer.intValue）方法调用来实现的。

　　Java 程序中的泛型信息会被擦除。具体来说，Java 编译器将选取该泛型所能指代的所有类中层次最高的那个，作为替换泛型的具体类。

　　由于 Java 语义与 Java 字节码中关于重写的定义并不一致，因此 Java 编译器会生成桥接方法作为适配器。

　　此外，我还介绍了 foreach 循环以及字符串 switch 的编译。

1. 自动装箱、自动拆箱
2. 泛型擦除
3. foreach循环的编译
4. switch的编译

1. 自动装箱、自动拆箱 

public int foo() {
  ArrayList<Integer> list = new ArrayList<>();
  list.add(0);  // Integer.valueOf()自动装箱  （基本型--> 包装类型）
  int result = list.get(0);    // Integer.intValue()的自动拆箱
  return result;
}

 

public int foo();
  Code:
     0: new java/util/ArrayList
     3: dup
     4: invokespecial java/util/ArrayList."<init>":()V
     7: astore_1
     8: aload_1
     9: iconst_0
    10: invokestatic java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
    13: invokevirtual java/util/ArrayList.add:(Ljava/lang/Object;)Z
    16: pop
    17: aload_1
    18: iconst_0
    19: invokevirtual java/util/ArrayList.get:(I)Ljava/lang/Object;
    22: checkcast java/lang/Integer
    25: invokevirtual java/lang/Integer.intValue:()I
    28: istore_2
    29: iload_2
    30: ireturn

 

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];  // 直接从缓存返回，否则new一个对象
    return new Integer(i);
}

 

2. 泛型擦除

package java8;

import java.util.ArrayList;

/**
 * 既然泛型会被类型擦除，那么我们还有必要用它吗？我认为是有必要的。Java 编译器可以根据泛型参数判断程序中的语法是否正确。
 * 举例来说，尽管经过类型擦除后，ArrayList.add 方法所接收的参数是 Object 类型，但是往泛型参数为 Integer 类型的
 *          ArrayList 中添加字符串对象，Java 编译器是会报错的。
 */
public class Foo {

    public int foo() {

        /**
         * 字节码如下
         13: invokevirtual java/util/ArrayList.add:(Ljava/lang/Object;)Z
         ...
         19: invokevirtual java/util/ArrayList.get:(I)Ljava/lang/Object;
         22: checkcast java/lang/Integer

         生成的字节码中，往 ArrayList 中添加元素的 add 方法，所接受的参数类型是 Object；
         而从 ArrayList 中获取元素的 get 方法，其返回类型同样也是 Object。
         */
        ArrayList<Integer> list = new ArrayList<>();
        list.add(0);
        int result = list.get(0);
        return result;
    }
}


class GenericTest<T extends Number> {

    /**
     * 当然，并不是每一个泛型参数被擦除类型后都会变成 Object 类。对于限定了继承类的泛型参数，经过类型擦除后，
     * 所有的泛型参数都将变成所限定的继承类。
     * 可以看到，foo 方法的方法描述符所接收参数的类型以及返回类型都为 Number。
     *
     *
     T foo(T);
     descriptor: (Ljava/lang/Number;)Ljava/lang/Number;
     flags: (0x0000)
     Code:
     stack=1, locals=2, args_size=2
     0: aload_1
     1: areturn
     Signature: (TT;)TT;
     *
     */
    T foo(T t) {
        return t;
    }
}

 

3. foreach循环的编译

 foreach 循环允许 Java 程序在 for 循环里遍历数组或者 Iterable 对象。对于数组来说，foreach 循环将从 0 开始逐一访问数组中的元素，直至数组的末尾。其等价的代码如下面所示：

public void foo(int[] array) {
  for (int item : array) {
  }
}
// 等同于
public void bar(int[] array) {
  int[] myArray = array;
  int length = myArray.length;
  for (int i = 0; i < length; i++) {
    int item = myArray[i];
  }
}

 

对于 Iterable 对象来说，foreach 循环将调用其 iterator 方法，并且用它的 hasNext 以及 next 方法来遍历该 Iterable 对象中的元素。其等价的代码如下面所示：

public void foo(ArrayList<Integer> list) {
  for (Integer item : list) {
  }
}
// 等同于
public void bar(ArrayList<Integer> list) {
  Iterator<Integer> iterator = list.iterator();
  while (iterator.hasNext()) {
    Integer item = iterator.next();
  }
}

4. switch的编译

package java8;

/**
 * 字符串 switch 编译而成的字节码看起来非常复杂，但实际上就是一个哈希桶。由于每个 case 所截获的字符串都是常量值，
 * 因此，Java 编译器会将原来的字符串 switch 转换为 int 值 switch，比较所输入的字符串的哈希值。
 *
 * 由于字符串哈希值很容易发生碰撞，因此，我们还需要用 String.equals 逐个比较相同哈希值的字符串。
 *
 * tableswitch用于case比较紧凑的代码，而lookup用于case比较分散的代码。
 * 如果不考虑空间的话，tableswitch指令比lookup指令有更高的执行效率。
 */
public class SwitchTest {

    /**
     *  1: lookupswitch  { // 2
     *                        1: 28
     *                        2: 39
     *                  default: 50
     *             }
     *
     */
    void switchGo(int inPut) {
        switch (inPut) {
            case 1:
                System.out.println("***********");
                break;
            case 2:
                System.out.println("#########");
                break;
            default:
                System.out.println("DEFAULT_&&");
                break;
        }
    }


    /**
     *  1: tableswitch   { // 0 to 2
     *                        0: 28
     *                        1: 30
     *                        2: 32
     *                  default: 34
     *             }
     *
     *
     */
    int chooseNear(int i) {
        switch (i) {
            case 0:  return  0;
            case 1:  return  1;
            case 2:  return  2;
            default: return -1;
        }
    }
}