' ...!= null'或“空！= ....”最好的表现？

Question

我编写了两个方法来检查性能

 public class Test1 {

 private String value;

 public void notNull(){
  if( value != null) {
    //do something
  }
}

public void nullNot(){
 if( null != value) {
  //do something
 }
}

}

，并在编译后检查它的字节码，

public void notNull();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: getfield #2; //Field value:Ljava/lang/String;
4: ifnull 7
7: return
LineNumberTable: 
line 6: 0
line 9: 7

StackMapTable: number_of_entries = 1
frame_type = 7 /* same */


public void nullNot();
Code:
Stack=2, Locals=1, Args_size=1
0: aconst_null
1: aload_0
2: getfield #2; //Field value:Ljava/lang/String;
5: if_acmpeq 8
8: return
LineNumberTable: 
line 12: 0
line 15: 8

StackMapTable: number_of_entries = 1
frame_type = 8 /* same */


}

这里使用两个操作码来实现 if 条件：在第一种情况下，它使用 ifnull- 检查堆栈的顶部值为 null-，在第二种情况下，它使用 if_acmpeq - 检查堆栈中前两个值是否相等 -

那么，这会对性能产生影响吗？ （这将帮助我证明 null 的第一个实现在性能方面以及可读性方面都很好:)）

Answer 1

比较生成的字节码基本上没有意义，因为大多数优化发生在 JIT 编译器的运行时。我猜测在这种情况下，任一表达式都同样快。如果有任何差异，那是可以忽略不计的。

这不是您需要担心的事情。寻找大局优化。

Answer 2

如果速度（或内存/无论情况如何）增益可以忽略不计，请勿以牺牲可读性为代价进行优化。我认为 !=null 通常更具可读性，所以使用它。

Answer 3

有了这样的问题，很难知道 JVM 有多智能（尽管答案是“如果可能的话通常非常智能”，并且在本例中看起来很有可能）。但为了确定，测试一下：

class Nullcheck {
  public static class Fooble { }

  Fooble[] foo = {null , new Fooble(), null , null,
                  new Fooble(), null, null, new Fooble() };

  public int testFirst() {
    int sum = 0;
    for (int i=0 ; i<1000000000 ; i++) if (foo[i&0x7] != null) sum++;
    return sum;
  }

  public int testSecond() {
    int sum = 0;
    for (int i=0 ; i<1000000000 ; i++) if (null != foo[i&0x7]) sum++;
    return sum;
  }

  public void run() {
    long t0 = System.nanoTime();
    int s1 = testFirst();
    long t1 = System.nanoTime();
    int s2 = testSecond();
    long t2 = System.nanoTime();
    System.out.printf("Difference=%d; %.3f vs. %.3f ns/loop (diff=%.3f)\n",
      s2-s1,(t1-t0)*1e-9,(t2-t1)*1e-9,(t0+t2-2*t1)*1e-9);
  }

  public static void main(String[] args) {
    Nullcheck me = new Nullcheck();
    for (int i=0 ; i<5 ; i++) me.run();
  }
}

在我的机器上，结果是：

Difference=0; 2.574 vs. 2.583 ns/loop (diff=0.008)
Difference=0; 2.574 vs. 2.573 ns/loop (diff=-0.001)
Difference=0; 1.584 vs. 1.582 ns/loop (diff=-0.003)
Difference=0; 1.582 vs. 1.584 ns/loop (diff=0.002)
Difference=0; 1.582 vs. 1.582 ns/loop (diff=0.000)

所以答案是：不，根本没有任何有意义的区别。 （JIT 编译器可以找到额外的技巧来加快相同次数的重复运行后的速度。）

---

更新：上面的代码运行一个临时基准测试。使用 JMH （现在它已经存在了！）是帮助避免的好方法（一些）微基准测试陷阱。上面的代码避免了最严重的陷阱，但它没有给出明确的错误估计，并且忽略了有时重要的各种其他事情。这些天：使用 JMH！另外，如有疑问，请运行您自己的基准测试。细节有时很重要——对于像这样简单的事情来说并不常见，但如果它对你来说真的很重要，你应该检查尽可能接近生产的条件。

Answer 4

除了在 C 语言中避免意外赋值的来之不易的智慧之外，这有利于将常量放在二元运算符的左侧，我发现左侧的常量更具可读性，因为它将关键的价值放在最突出的位置。

通常，函数体仅使用几个变量，并且通常通过上下文可以清楚地看出正在检查哪个变量。通过将常量放在左侧，我们可以更接近地模拟 switch 和 case：给定 this 变量，选择一个匹配值。看到左侧的值，人们会关注所选择的特定条件。

当我扫描时

if (var == null)

，我将其读为“我们正在检查 var 这里，我们正在比较它的相等性，与......啊，null。”相反，当我扫描时

if (null == var)

，我想，“我们正在查看一个值是否为 null，并且......是的，我们正在检查的是 var”。这是一种更强烈的认可，

if (null != var)

我的眼睛立刻就注意到了。

这种直觉来自于习惯的一致性，喜欢读自己写的东西，写自己喜欢读的东西。人们可以通过任何一种方式来学习它，但这并不客观正确，因为其他人在这里回答说将变量放在左侧更清晰。这取决于人们首先想把表达的哪一方面说得最清楚。

看到字节码的差异是令人着迷的。感谢您分享这一点。

Answer 5

差异可以忽略不计，所以选择最具可读性的内容（!= null imo）

Answer 6

为了便于阅读，我会坚持使用 (value != null) 。但您始终可以使用断言。

Answer 7

像这样的微小优化是编译器的工作，特别是在像 Java 这样的高级语言中。

虽然严格来说它与这里无关，但不要过早优化！

Answer 8

从性能上来看，并没有太大的区别。

然而，先写入 null 来捕获拼写错误是很有用的。

例如，如果你习惯写这样的代码：

if (obj == null)

可能会被错误地写成：

if (obj = null)

从编译器的角度来看，这没问题。

但是，如果您习惯将代码编写为：

if (null == obj)

并且错误地编写了：

if (null = obj)

编译器会让您知道您在该行中犯了错误。

Answer 9

首先放置 null 似乎会生成额外的字节码，但除此之外可能不会有性能差异。

就我个人而言，在需要担心性能之前我不会担心性能。

我会使用 notNull() 方法，这样如果您忘记 ! 并意外键入 null = value ，就不会引发编译器错误>。

Answer 10

哦，如果你要求终极性能，就不要创建额外的类或方法。即使是静态方法也会花费一些时间，因为 Java 类加载器需要 JIT 加载它。

因此，每当您需要检查变量是否为空时，您只需通过以下任一方法进行测试

if (x == null)

即可

if (null == x)

坦率地说，我认为选择两者之一的性能奖励很容易被引入不必要的方法的开销所抵消。

Answer 11

您可以在编码过程中忽略这些非常微小的优化内容

Answer 12

正如您所看到的，性能差异非常小。不要担心小事情，更多地关注算法总是更好。显然可读性是一个因素。

Answer 13

我会使用“新”Java 8 功能，我写了几个例子：

import java.util.Optional;

public class SillyExample {

public void processWithValidation(final String sampleStringParameter){
    final String sampleString = Optional.ofNullable(sampleStringParameter).orElseThrow(() -> new IllegalArgumentException("String must not be null"));

    //Do what you want with sampleString
}


public void processIfPressent(final String sampleStringParameter){
    Optional.ofNullable(sampleStringParameter).ifPresent(sampleString -> {

        //Do what you want with sampleString

    });

}

public void processIfPressentWithFilter(final String sampleStringParameter){
    Optional.ofNullable(sampleStringParameter).filter("hello"::equalsIgnoreCase).ifPresent(sampleString -> {

        //Do what you want with sampleString

    });

}

}

Answer 14

在 Java-8 中，Objects 类引入了两个附加方法：
对象#nonNull 和 Objects#isNull，您可以使用它来替换 null 检查。有趣的是，他们都首先使用对象：

public static boolean isNull(Object obj) {
    return obj == null;
}

并且

public static boolean nonNull(Object obj) {
    return obj != null;
}

相应地。我猜这意味着这是推荐的方式（至少核心jdk开发人员使用了这种方式）
对象源代码

Answer 15

我更喜欢 null != object 因为它清楚地表明它只是用于 null 检查。

Answer 16

字节码只是源代码的简单翻译。