java1.7 switch_jdk1.7 String switch的实现

对于int的switch，jvm是用tableswitch和lookupswitch来实现的，jdk1.7 switch增加了对string的支持，那么底层是如何实现的呢？是否增加了新的指令或是否给某些指令增加了新的含义？

看这样一个程序：

Java代码  

public class Test {

public static void main(String[] args) {

String name = "b";

int value = 0;

switch(name) {

case "a":

value = 1;

break;

case "b":

value = 2;

break;

case "c":

value = 3;

break;

case "d":

value = 4;

break;

case "e":

value = 5;

break;

default:

value = 6;

}

System.out.println(value);

}

}

javap -c Test得出的结果为：

Java代码  

public static void main(java.lang.String[]);

Code:

0: ldc           #2                  // String b

2: astore_1                    //将"b"赋值给name

3: iconst_0                    //将0入栈

4: istore_2                    //将0赋值给value

5: aload_1                 //将name(即"b")入栈

6: astore_3                    //将name(即"b")赋值给一个编译器生成的变量，记为tmpName(tmpName此时也是"b")

7: iconst_m1                   //将-1入栈

8: istore        4         //将-1赋值给一个编译器生成的变量，记为m1

10: aload_3                 //将tmpName(即"b")入栈

11: invokevirtual #3                  // Method java/lang/String.hashCode:()I       调用tmpName的hashCode方法("b".hashCode()，得结果98)

14: tableswitch   { // 97 to 101        //根据hashCode的值到不同的分支

97: 48

98: 63                    //这里走到这个分支，跳转到63

99: 78

100: 93

101: 108

default: 120

}

48: aload_3

49: ldc           #4                  // String a

51: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z

54: ifeq          120

57: iconst_0

58: istore        4

60: goto          120

63: aload_3                         //从14跳转到了这里，将tmpName(即"b")入栈

64: ldc           #2                  // String b       将"b"入栈

66: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z

//比较tmpName和"b"，如果相等，将1入栈，不等将0入栈.这里是相等的，入栈的为1

69: ifeq          120                   //从栈顶取出比较结果，如果等于0，就跳到120，如果不等于0就继续下面的指令，这里显然不等于0

72: iconst_1                            //将1入栈

73: istore        4                 //将1存储到m1中

75: goto          120                   //跳到120

78: aload_3

79: ldc           #6                  // String c

81: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z

84: ifeq          120

87: iconst_2

88: istore        4

90: goto          120

93: aload_3

94: ldc           #7                  // String d

96: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z

99: ifeq          120

102: iconst_3

103: istore        4

105: goto          120

108: aload_3

109: ldc           #8                  // String e

111: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z

114: ifeq          120

117: iconst_4

118: istore        4

120: iload         4                 //将m1(即73行存进去的1)的值入栈

122: tableswitch   { // 0 to 4

0: 156

1: 161                   //这里走1这个分支，跳到161

2: 166

3: 171

4: 176

default: 181

}

156: iconst_1

157: istore_2

158: goto          184

161: iconst_2                    //将2入栈

162: istore_2                    //将2存储到value

163: goto          184           //跳转到184进行打印输出

166: iconst_3

167: istore_2

168: goto          184

171: iconst_4

172: istore_2

173: goto          184

176: iconst_5

177: istore_2

178: goto          184

181: bipush        6

183: istore_2

184: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;

187: iload_2

188: invokevirtual #10                 // Method java/io/PrintStream.println:(I)V

191: return

在这一堆指令中我们发现，jdk1.7并没有新指令来处理string switch，还是继续用lookupswitch和tableswitch两个指令来处理的，也没有扩展这两个指令，它们还是只能处理int。

在11行，我们看到调用了需要switch的string的hashCode方法，并对该hashCode进行switch，并跳转到相应的处理指令。跳到新的指令处我们发现这里(63行)将待switch的变量(name)与case中的值("b")equals了一下。这样做是为了避免不同的string有相同的hashCode，确定equals返回true后，编译器生成了一个处理value的switch，源码里有多少个case编译器生成的tableswitch就有多少个分支，最终会找到相应的处理分支完成string switch的处理。

接下来，看一个不同string hashCode相等的版本：

buzzards与righto的hashCode相等

hierarch与crinolines的hashCode相等

这里选择buzzards和righto

Java代码  

public class Test {

public static void main(String[] args) {

String name = "buzzards";

int value = 0;

switch(name) {

case "buzzards":

value = 1;

break;

case "righto":

value = 2;

break;

default:

value = 6;

}

System.out.println(value);

}

}

字节码：

Java代码  

public static void main(java.lang.String[]);

Code:

0: ldc           #2                  // String buzzards

2: astore_1

3: iconst_0

4: istore_2

5: aload_1

6: astore_3

7: iconst_m1

8: istore        4

10: aload_3

11: invokevirtual #3                  // Method java/lang/String.hashCode:()I

14: lookupswitch  { // 1

-931102253: 32

default: 59

}

32: aload_3

33: ldc           #4                  // String righto

35: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)

38: ifeq          47

41: iconst_1

42: istore        4

44: goto          59

47: aload_3

48: ldc           #2                  // String buzzards

50: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)

53: ifeq          59

56: iconst_0

57: istore        4

59: iload         4

61: lookupswitch  { // 2

0: 88

1: 93

default: 98

}

88: iconst_1

89: istore_2

90: goto          101

93: iconst_2

94: istore_2

95: goto          101

98: bipush        6

100: istore_2

101: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;

104: iload_2

105: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V

108: return

这里我们看到两个字符串都跳到32行，首先跟"righto"比较，如果不相等则跳到47行比较buzzards。