我查看了新的 Java 8 Map 方法(如 getOrDefault)的默认实现，发现有些奇怪。例如考虑 getOrDefault 方法。具体实现如下。

default V getOrDefault(Object key, V defaultValue) {
    V v;
    return ((v = get(key)) != null) || containsKey(key) ? v : defaultValue;
}

现在，这里“奇怪”的事情是 ((v = get(key)) != null 中的“使用赋值结果”模式。据我所知，不鼓励使用这种特定模式, 因为它相当妨碍可读性。IMO 更简洁的版本将类似于

default V getOrDefault(Object key, V defaultValue) {
    V v = get(key);
    return v != null || containsKey(key) ? v : defaultValue;
}

我的问题是，除了编码标准/习惯之外，是否有任何特别的理由使用前者而不是后者模式。特别是，我想知道这两个版本是否在跟踪和性能方面是等效的？

我唯一能想到的是编译器可能例如确定 containsKey 通常可以更快地进行评估，因此首先对其进行评估，但据我所知，短路必须保留执行顺序(至少 C 是这种情况)。

编辑:按照@ruakh 的建议，这是两个字节码(由javap -c 生成)

  public V getOrDefault(java.lang.Object, V);
    Code:
       0: aload_0
       1: aload_1
       2: invokeinterface #1,  2            // InterfaceMethod get:(Ljava/lang/Object;)Ljava/lang/Object;
       7: dup                               // <-- difference here
       8: astore_3
       9: ifnonnull     22
      12: aload_0
      13: aload_1
      14: invokeinterface #2,  2            // InterfaceMethod containsKey:(Ljava/lang/Object;)Z
      19: ifeq          26
      22: aload_3
      23: goto          27
      26: aload_2
      27: areturn

和

  public V getOrDefault(java.lang.Object, V);
    Code:
       0: aload_0
       1: aload_1
       2: invokeinterface #1,  2            // InterfaceMethod get:(Ljava/lang/Object;)Ljava/lang/Object;
       7: astore_3
       8: aload_3                           // <-- difference here
       9: ifnonnull     22
      12: aload_0
      13: aload_1
      14: invokeinterface #2,  2            // InterfaceMethod containsKey:(Ljava/lang/Object;)Z
      19: ifeq          26
      22: aload_3
      23: goto          27
      26: aload_2
      27: areturn

我不得不承认，即使经过多年的 Java 编码，我仍然不知道如何解释 Java 字节码。有人能解释一下这里的区别吗？

最佳答案

这只是一个样式问题。有些人喜欢尽可能紧凑的代码， 而其他人则更喜欢更长但更简单的代码。好像有些开发商 从事 Java 核心库的工作属于前一组。

就效率而言，两种变体是相同的。

让我们看看编译器实际上对这两个变体做了什么:

public class ExampleMap<K, V> extends HashMap<K, V> {

    V getOrDefault1(Object key, V defaultValue) {
        V v;
        return ((v = get(key)) != null) || containsKey(key) ? v : defaultValue;
    }

    V getOrDefault2(Object key, V defaultValue) {
        V v = get(key);
        return v != null || containsKey(key) ? v : defaultValue;
    }
}

现在让我们使用 javap -c ExampleMap 转储生成的字节码:

Compiled from "ExampleMap.java"
public class ExampleMap<K, V> extends java.util.HashMap<K, V> {
  public ExampleMap();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/util/HashMap."<init>":()V
       4: return

  V getOrDefault1(java.lang.Object, V);
    Code:
       0: aload_0
       1: aload_1
       2: invokevirtual #2                  // Method get:(Ljava/lang/Object;)Ljava/lang/Object;
       5: dup
       6: astore_3
       7: ifnonnull     18
      10: aload_0
      11: aload_1
      12: invokevirtual #3                  // Method containsKey:(Ljava/lang/Object;)Z
      15: ifeq          22
      18: aload_3
      19: goto          23
      22: aload_2
      23: areturn

  V getOrDefault2(java.lang.Object, V);
    Code:
       0: aload_0
       1: aload_1
       2: invokevirtual #2                  // Method get:(Ljava/lang/Object;)Ljava/lang/Object;
       5: astore_3
       6: aload_3
       7: ifnonnull     18
      10: aload_0
      11: aload_1
      12: invokevirtual #3                  // Method containsKey:(Ljava/lang/Object;)Z
      15: ifeq          22
      18: aload_3
      19: goto          23
      22: aload_2
      23: areturn
}

如您所见，代码大部分相同。唯一的小区别是线条 两种方法的5和6。一个只是复制堆栈的顶部值 (记住，Java 字节码采用基于堆栈的机器模型)，而另一个 从实例变量加载(相同的)值。

当即时编译器根据这个字节生成真正的机器代码时 代码，它将执行各种优化，比如决定哪些值 写回 RAM 并将其保存在 CPU 寄存器中。我认为这是安全的 假设在这些优化发生之后，没有区别 留下任何东西。

关于Java 8 Map 默认实现细节，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44151328/