新的Java17型模式匹配开关如何在引擎盖下工作？

Question

新的Java17型模式匹配开关如何在引擎盖下工作？由于该功能相当新，本问题不讨论它。

提醒：要使此代码在Java 17下工作，需要启用预览功能

public static void test (Object o) {
  System.out.println(switch(o){
    case Number n -> "number " + n;
    case Enum e -> "enum " + e;
    case String s -> "string " + s;
    default -> "other " + o;
  });
}

使用javap-c对上述代码进行了反汇编：

   0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
   3: aload_0
   4: dup
   5: invokestatic  #13                 // Method java/util/Objects.requireNonNull:(Ljava/lang/Object;)Ljava/lang/Object;
   8: pop
   9: astore_1
  10: iconst_0
  11: istore_2
  12: aload_1
  13: iload_2
  14: invokedynamic #19,  0             // InvokeDynamic #0:typeSwitch:(Ljava/lang/Object;I)I
  19: tableswitch   { // 0 to 2
                 0: 44
                 1: 58
                 2: 74
           default: 90
      }
  44: aload_1
  45: checkcast     #23                 // class java/lang/Number
  48: astore_3
  49: aload_3
  50: invokedynamic #25,  0             // InvokeDynamic #1:makeConcatWithConstants:(Ljava/lang/Number;)Ljava/lang/String;
  55: goto          96
  58: aload_1
  59: checkcast     #29                 // class java/lang/Enum
  62: astore        4
  64: aload         4
  66: invokedynamic #31,  0             // InvokeDynamic #2:makeConcatWithConstants:(Ljava/lang/Enum;)Ljava/lang/String;
  71: goto          96
  74: aload_1
  75: checkcast     #34                 // class java/lang/String
  78: astore        5
  80: aload         5
  82: invokedynamic #36,  0             // InvokeDynamic #3:makeConcatWithConstants:(Ljava/lang/String;)Ljava/lang/String;
  87: goto          96
  90: aload_0
  91: invokedynamic #39,  0             // InvokeDynamic #4:makeConcatWithConstants:(Ljava/lang/Object;)Ljava/lang/String;
  96: invokevirtual #42                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
  99: return

鉴于这一关键点：

  14: invokedynamic #19,  0             // InvokeDynamic #0:typeSwitch:(Ljava/lang/Object;I)I

看起来Java在自动生成的int-typeSwitch（object，int）方法中将对象转换为int，我看不到生成的代码。这种转换的目标是能够在int值上使用常规的切换表。

起初，我认为使用了的hashCode，即对象。getClass（）。hashCode（），就像切换字符串一样，但实际上类对象的哈希代码在JVM的连续运行中并不是常数。因此，除非在每次执行时都重建映射表，否则这是不可能的，我怀疑的是。

因此，问题是：

这个typeSwitch方法做什么？

它是否比一系列if instanceof或if instanceof更聪明？这可能吗？

传递额外int的目的是什么？

Answer 1

这个typeSwitch（）方法做什么？

invokeDynamic指令（第一次命中时）调用SwitchBootstraps。typeSwitch（）方法。然后，此方法返回应该执行的方法调用（这是InvokedDynamic通常所做的）。

SwitchBootstraps的最后一个参数。typeSwitch（）方法（标签参数）在本例中是开关中的类列表：编号。类，枚举。类，字符串。类别

SwitchBootstraps.typeSwitch（）bootstrap方法检查标签参数的正确性，然后为执行有效处理的SwitchBootstraps.doTypeSwitch（）方法返回ConstantCallSite（例如，调用动态指令的最终执行）。

如果您查看SwitchBootstraps.doTypeSwitch（）的作用：它遍历类列表并返回第一个找到的匹配项。

额外传递的int的目的是什么？

由于这种情况，需要附加参数（startIndex）：

public static void test(Object o) {
    System.out.println(switch(o){
        case Number n && n.intValue() >= 10 -> "large number " + n;
        case Number n -> "small number "+ n;
        case Enum e -> "enum " + e;
        case String s -> "string " + s;
        default -> "other " + o;
    });
}

现在有两种情况与类java.lang.Number匹配，第一种情况由条件n保护

如果我调用test（5），则将使用要测试的对象（Integer.valueOf（5））调用doTypeSwitch（）方法，即0的startIndex和类列表。它迭代类列表，并在找到第一个编号条目并返回其索引（0）时立即停止。

它开始处理第一个案例并检查防护装置。因为我用值5调用它，所以保护失败，代码循环回doTypeSwitch（）调用。然而，这次它是用对象来调用的，以测试（Integer.valueOf（5）），一个1的开始索引和相同的类列表。

代码是否比列表更智能（或更快）if（o instanceof Number n

在当前状态下肯定不会更快。但是请记住，这是第一次迭代（https://openjdk.java.net/jeps/406）中的预览功能：Java架构师正在试验此功能，获得typeSwitch的最佳性能可能不是第一个问题。

这个特性已经有了第二次迭代（https://openjdk.java.net/jeps/420），一旦设计完成，未来的版本可能会提高性能。

但即便如此：要使用if/else if链实现测试（对象o）方法，您必须将该方法分为两部分：

public static void test2(Object o) {
    System.out.println(check2(o));
}

private static String check2(Object o) {
    if (o instanceof Number n && n.intValue() >= 10)
        return "large number " + n;
    else if (o instanceof Number n)
        return "small number "+ n;
    else if (o instanceof Enum e)
        return "enum " + e;
    else if (o instanceof String s)
        return "string " + s;
    else
        return "other " + o;
}

这大约是行数的两倍。

那（让它更聪明）可能吗？

这至少是可以想象的。可以重新排列类标签，可以根据类标签的类层次结构将它们做成树结构，或者根据最常用的路径在运行时执行一些其他智能操作。