java空检查语法差异

到目前为止发布的任何java版本中是否存在性能差异

福！=空的

及

空！=福

---

我个人认为上述两种形式的对象空检查的行为没有任何变化，但不确定哪一种性能更好。我知道如果有的话，差别会很小，但我想知道为什么有人用那种方式编写所有代码。

这种方式是关于尤达风格的。这只是个人喜好的问题

Yoda条件-使用if常量==变量而不是if 变量==常量，如4==foo。因为这就像说 如果天空是蓝色的，如果人是高大的

---

时尚是关于尤达风格的。这只是个人喜好的问题

Yoda条件-使用if常量==变量而不是if 变量==常量，如4==foo。因为这就像说 如果天空是蓝色的，如果人是高大的

。所以顺序在语义上并不重要

传统的方式是把你要检查的东西放在第一位，常数放在最后。这至少遵循了许多欧洲语言形式，例如x是否为空？不是空x

在历史上的某一时刻，人们习惯于在C中编写if NULL==x。这是为了让编译器在NULL=x时发现一个意外的语法错误，因为它说您不能赋值给常量。标准代码质量工具现在可以识别这些类型的错误，因此这种做法现在已经过时。

。所以顺序在语义上并不重要

传统的方式是把你要检查的东西放在第一位，常数放在最后。这至少遵循了许多欧洲语言形式，例如x是否为空？不是空x

---

在历史上的某一时刻，人们习惯于在C中编写if NULL==x。这是为了让编译器在NULL=x时发现一个意外的语法错误，因为它说您不能赋值给常量。标准代码质量工具现在可以识别这些类型的错误，因此这种做法现在已经过时。

不，这两种形式之间没有区别

不管怎样，都有以下指令-加载foo的值，与0 null进行比较并读取比较结果

---

现在，如果是equals方法，那就不同了：

不，这两种形式之间没有区别

不管怎样，都有以下指令-加载foo的值，与0 null进行比较并读取比较结果

---

现在，如果是equals方法，那就不同了：

除了表单可读性透视图foo！=空值更好。因为通常在左边，我们把我们想要比较的东西和右边的值放在一起。一般来说，我们将比较像foo这样的对象和null

除了表单可读性透视图foo！=空值更好。因为通常在左边，我们把我们想要比较的东西和右边的值放在一起。一般来说，我们将比较像foo这样的对象和null

这源于古老的C时代。它以foo==null==foo开始

在c语法中是有效的，编译器没有抱怨：

if (foo = null) {
}

为防止此细微错误，已开始使用以下语法：

if (null == foo) {
}

因为null是常数 如果null=foo{ }

变成语法错误

在java中，只有一种情况与此有关：

boolean someBoolean;
if (someBoolean = true) {
}

是运行时错误，但编译

这个

是编译错误

---

没有性能问题，只是在某些情况下防止了错误。

这源于旧的C时代。它以foo==null==foo开始

public class Stack
{
    public static void main(String[] args)
    {
        Object obj0 = null;
        Object obj1 = new Object();
        long start;
        long end;
        double difference;  
        double differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (obj0 == null);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);
        differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (null == obj0);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);
        differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (obj1 == null);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);
        differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (null == obj1);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);      
    }
}

在c语法中是有效的，编译器没有抱怨：

if (foo = null) {
}

为防止此细微错误，已开始使用以下语法：

if (null == foo) {
}

因为null是常数 如果null=foo{ }

变成语法错误

在java中，只有一种情况与此有关：

boolean someBoolean;
if (someBoolean = true) {
}

是运行时错误，但编译

这个

是编译错误

没有性能问题，在某些情况下只有错误预防

public class Stack
{
    public static void main(String[] args)
    {
        Object obj0 = null;
        Object obj1 = new Object();
        long start;
        long end;
        double difference;  
        double differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (obj0 == null);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);
        differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (null == obj0);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);
        differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (obj1 == null);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);
        differenceAvg = 0;

        for (int j = 0; j < 100; j++)
        {
            start = System.nanoTime();

            for (int i = 0; i < 1000000000; i++)
                if (null == obj1);

            end = System.nanoTime();
            difference = end - start;
            differenceAvg +=difference;
        }

        System.out.println(differenceAvg/100);      
    }
}

在初始化对象的情况下，不会收集任何内容；然而，当对象为null时，在几乎所有的平均情况下，obj0==null都比null==obj0快。我又执行了21次死刑，其中20次就是这样

---

在初始化对象的情况下，不会收集任何内容；然而，当对象为null时，在几乎所有的平均情况下，obj0==null都比null==obj0快。我又执行了21次死刑，其中20次就是这样

我不认为有性能上的差异。如果有，应该很难衡量。除了表单可读性透视图foo！=空值更好。因为通常在左边，我们把我们想要比较的东西和右边的值放在一起。一般来说，我们会比较像foo这样的对象和nul

---

L从逻辑上讲，没有必要根据foo检查null。有关Yoda条件的更多信息，请参阅。在某些C循环中，它们作为一种避免意外赋值而不是比较编译器错误的方法非常流行，因为常量不是左值。性能如果我看到他们的表现不同，我会非常惊讶。我在回答中发现了一个非常有趣的结果。我不认为他们有性能上的差异。如果有，应该很难衡量。除了表单可读性透视图foo！=空值更好。因为通常在左边，我们把我们想要比较的东西和右边的值放在一起。一般来说，我们将比较像foo这样的对象和null。从逻辑上讲，没有必要根据foo检查null。有关Yoda条件的更多信息，请参阅。在某些C循环中，它们作为一种避免意外赋值而不是比较编译器错误的方法非常流行，因为常量不是左值。性能如果我看到他们的表现不同，我会非常惊讶。我在回答中发现了一个非常有趣的结果。这让我做了一些测试，并在另一篇文章中发表了一篇文章。我试图弄清楚，当对象被初始化时，与它为null时相比，什么样的比较速度更快。我们的结果与您编写代码的方式以及调用不同测试用例的顺序并不完全一致。我太仓促了，没有接受我认为可能但事实并非如此的事情。这让我做了一些测试，并在另一篇文章中发表了一篇文章。我试图弄清楚，当对象被初始化时，与它为null时相比，什么样的比较速度更快。我们的结果与您编写代码的方式以及调用不同测试用例的顺序并不完全一致。我太仓促了，没有接受我认为可能但事实并非如此的事情。比他们中的大多数人回答得更好。比他们中的大多数人回答得更好。