Java st表示空值检查。polygene的答案是你应该听的答案。但是如果你真的认为差异很重要，那么把每个版本运行10亿次左右，看看是否有任何可测量的差异。然后回来告诉我们。为什么这很重要呢，你的程序只有3行那么长，如果语句运行的话，它的速度有多快或多慢如此重要？

---

---

st表示空值检查。

polygene的答案是你应该听的答案。但是如果你真的认为差异很重要，那么把每个版本运行10亿次左右，看看是否有任何可测量的差异。然后回来告诉我们。为什么这很重要呢，你的程序只有3行那么长，如果语句运行的话，它的速度有多快或多慢如此重要？当我们谈到这个问题时，我想证明，将开头的花括号与条件括号放在同一行比其他括号样式更有效。我要说，OP需要因努力、挖掘字节码等而受到表扬。如果方向正确，这种决心将对OP有好处。我同意你关于可读性的说法。null是常量，对于包含常量的比较而言，变量常量是可读性最好的。但是在if条件下，如果你犯了同样的错误，它将不会编译，如果not value是布尔类型，我认为键入

notNull（value）

比

value！=空

。是的，我同意，我的意思是在执行类型检查时讲一般性，但我没有说清楚。谢谢你。+1区分字节码和汇编代码-这是一个非常重要的区别需要注意。这真的很简单：如果一个比另一个快，微软的一些聪明人会让编译器或JIT将慢的转换成快的。字节码很好，但是你怎么知道这不是一个大的优化？如果您查看的是稀疏填充的数据，检查null可能是您的代码花费大部分时间的地方。@Nicolas，考虑到这是java，而不是c#，Microsoft的人员可能会让编译器将快速的转换为慢速的：）啊。在“我患有多动症的证据”列表中添加另一项。每个人都有自己的直觉。。。（尽管你在这一点上肯定是错的。；）“避免在C中意外赋值的来之不易的智慧”已经过时20年了，因为C编译器现在会发出警告（而不必从“lint”中获取），编译器现在对此发出警告并不能改变长期程序员最初采用这种风格的原因，但这并不重要。我在这里的观点是，避免这种意外的分配并不是这种风格的唯一好处，而且今天仍然有很好的理由采用它。根据读者最感兴趣的内容，这种风格可以“读得更好”。这完全取决于您使用的编译器。我相信这些方法只是作为一种简单的方式介绍的，以查看生成的字节码中的差异。这一点已经讨论过，请参阅。你应该编辑这个答案来解释为什么你认为这是有用的，即使那些评论者说它不是。

 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 (x == null)

if (null == x)

if (var == null)

if (null == var)

if (null != var)

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)

if (obj == null)

if (obj = null)

if (null == obj)

if (null = obj)

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

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

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

    });

}