java - borde - ¿Por qué encender la cadena compila en dos interruptores?

text panel java

Question

Leí la especificación de JVM al compilar los conmutadores y me interesé en cómo se compila la instrucción de conmutador en String. Aquí está el método de prueba que examiné (JDK1.7.0_40):

static int test(String i) {
    switch (i) {
        case "a":  return  -100;
        case "45b":  return  1;
        case "c":  return  2;
        default: return -1;
    }
}

Espero que este método se compile en un simple interruptor de búsqueda en el código hash de la cadena, pero de repente

static int test(java.lang.String);
Code:
   0: aload_0
   1: astore_1
   2: iconst_m1
   3: istore_2
   4: aload_1
   5: invokevirtual #6         // Method java/lang/String.hashCode:()I
   8: lookupswitch  { // 3
                97: 44
                99: 72
             51713: 58
           default: 83
      }
  44: aload_1
  45: ldc           #7 // String a
  47: invokevirtual #8 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
  50: ifeq          83
  53: iconst_0
  54: istore_2
  55: goto          83
  58: aload_1
  59: ldc           #9  // String 45b
  61: invokevirtual #8  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
  64: ifeq          83
  67: iconst_1
  68: istore_2
  69: goto          83
  72: aload_1
  73: ldc           #10 // String c
  75: invokevirtual #8  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
  78: ifeq          83
  81: iconst_2
  82: istore_2
  83: iload_2
  84: tableswitch   { // 0 to 2
                 0: 112
                 1: 115
                 2: 117
           default: 119
      }
 112: bipush        -100
 114: ireturn
 115: iconst_1
 116: ireturn
 117: iconst_2
 118: ireturn
 119: iconst_m1
 120: ireturn

Como puede ver, en las ramas del primer buscador JVM no está haciendo el trabajo real generando índices para el siguiente interruptor de tabla (línea 84).
Tableswitch debería trabajar rápido para que no traiga mucho trabajo extra. Pero de todos modos, ¿cuál es el propósito de generar un switch adicional?
Actualizar
Entiendo la posibilidad de colisiones hashCode. Lo que estoy tratando de decir es que, en lugar de los conmutadores de tablas subsiguientes, el compilador podría mover todo el trabajo real del conmutador de tablas subsiguientes al primero y luego usar ifeq para saltar al final de todas las ramas de switch. Entonces, la única respuesta posible que veo aquí es que, en el primer compilador, el conmutador intenta calcular previamente la etiqueta para el salto ifeq en función de un número conocido de casos, pero no estoy seguro de que sea la única razón.

Actualización2
Como @ericbn sugirió, traté de compilar

switch (i) { 
   case 97: return -100; 
   case 51713: return 1; 
   case 99: return 2; 
   default: return -1;
}

con i como int y el compilador me dio un simple lookupswitch.

Answer 1

La cita del código fuente de javac :

         * The general approach used is to translate a single
         * string switch statement into a series of two chained
         * switch statements: the first a synthesized statement
         * switching on the argument string''s hash value and
         * computing a string''s position in the list of original
         * case labels, if any, followed by a second switch on the
         * computed integer value.  The second switch has the same
         * code structure as the original string switch statement
         * except that the string case labels are replaced with
         * positional integer constants starting at 0.
         *
         * The first switch statement can be thought of as an
         * inlined map from strings to their position in the case
         * label list.  An alternate implementation would use an
         * actual Map for this purpose, as done for enum switches.
         *
         * With some additional effort, it would be possible to
         * use a single switch statement on the hash code of the
         * argument, but care would need to be taken to preserve
         * the proper control flow in the presence of hash
         * collisions and other complications, such as
         * fallthroughs.  Switch statements with one or two
         * alternatives could also be specially translated into
         * if-then statements to omit the computation of the hash
         * code.