在Java中（a == 1 && a == 2 && a == 3）可以评估为true吗？

我们知道它可以在JavaScript中使用。

但是是否可以在下面的Java条件下打印“成功”消息？

if (a==1 && a==2 && a==3) {
    System.out.println("Success");
}

有人建议：

int _a = 1;
int a  = 2;
int a_ = 3;
if (_a == 1 && a == 2 && a_ == 3) {
    System.out.println("Success");
}

但是通过这样做，我们正在更改实际变量。还有其他办法吗？

是的，如果您将变量声明a为volatile ，那么使用多个线程即可轻松实现。

一个线程不断将变量a从1更改为3，而另一个线程不断对其进行测试a == 1 && a == 2 && a == 3。它经常发生，足以在控制台上连续打印“成功”流。

（请注意，如果添加一个else {System.out.println("Failure");}子句，您会发现测试失败的次数远远超过成功的次数。）

实际上，它在不声明a为易失性的情况下也可以工作，但在我的MacBook上只有21次。如果没有volatile，则允许编译器或HotSpot缓存a或将if语句替换为if (false)。最有可能的是，HotSpot会在一段时间后启动，并将其编译为确实会缓存的值的汇编指令a。使用 volatile，它将永远打印“成功”。

public class VolatileRace {
    private volatile int a;

    public void start() {
        new Thread(this::test).start();
        new Thread(this::change).start();
    }

    public void test() {
        while (true) {
            if (a == 1 && a == 2 && a == 3) {
                System.out.println("Success");
            }
        }
    }

    public void change() {
        while (true) {
            for (int i = 1; i < 4; i++) {
                a = i;
            }
        }
    }

    public static void main(String[] args) {
        new VolatileRace().start();
    }
}

使用出色的代码高尔夫球答案中的概念（和代码），Integer就可以弄乱值。

在这种情况下，通常情况下，ints 可以使s Integer等于s：

import java.lang.reflect.Field;

public class Test
{
    public static void main(String[] args) throws Exception
    {
        Class cache = Integer.class.getDeclaredClasses()[0];
        Field c = cache.getDeclaredField("cache");
        c.setAccessible(true);
        Integer[] array = (Integer[]) c.get(cache);
        // array[129] is 1
        array[130] = array[129]; // Set 2 to be 1
        array[131] = array[129]; // Set 3 to be 1

        Integer a = 1;
        if(a == (Integer)1 && a == (Integer)2 && a == (Integer)3)
            System.out.println("Success");
    }
}

不幸的是，它不如Erwin Bolwidt的多线程答案 那么优雅（因为此Integer答案需要强制转换），但是仍然有一些有趣的恶作剧。

在这个问题上 @ aioobe建议（并建议）对Java类使用C预处理器。

尽管它非常狡猾，但这是我的解决方案：

#define a evil++

public class Main {
    public static void main(String[] args) {
        int evil = 1;
        if (a==1 && a==2 && a==3)
            System.out.println("Success");
    }
}

如果使用以下命令执行，它将输出正好一个Success：

cpp -P src/Main.java Main.java && javac Main.java && java Main

我们已经知道，由于Erwin Bolwidt和phflack的出色回答，可以使此代码的评估结果为true ，我想表明在处理看起来像这样的条件时，您需要保持高度关注在问题中，有时您所看到的可能与您所认为的不完全相同。

这是我的尝试，以显示此代码可打印Success!到控制台。我知道我有点作弊，但是我仍然认为这是在此处展示它的好地方。

不管编写这样的代码的目的是什么-更好地了解如何处理以下情况以及如何检查您认为自己所看到的内容是否正确。

我使用西里尔字母“ a”，这与拉丁字母“ a”不同。您可以在此处检查if语句中使用的字符。

之所以可行，是因为变量名称取自不同的字母。它们是不同的标识符，创建两个不同的变量，每个变量具有不同的值。

请注意，如果您希望此代码正常工作，则需要将字符编码更改为支持两种字符的编码，例如所有Unicode编码（UTF-8，UTF-16（在BE或LE中），UTF-32甚至UTF-7） ），或Windows-1251，ISO 8859-5，KOI8-R（感谢您-Thomas Weller和PaŭloEbermann-指出）：

public class A {
    public static void main(String[] args) {
        int а = 0;
        int a = 1;
        if(а == 0 && a == 1) {
            System.out.println("Success!");
        }
    }
}

（我希望您以后再也不必处理此类问题了。）

使用PowerMock的功能，还有另一种方法可以解决此问题（除了我之前发布的易失性数据跟踪方法）。PowerMock允许将方法替换为其他实现。当与自动拆箱结合使用时，原始表达式(a == 1 && a == 2 && a == 3)无需修改即可变为真。

@phflack的答案取决于使用Java修改Java中的自动装箱过程 Integer.valueOf(...)调用的。以下方法依赖于通过更改Integer.intValue()呼叫来修改自动拆箱。

下面这种方法的优点是，OP在问题中给出的原始if语句保持不变，我认为这是最优雅的。

import static org.powermock.api.support.membermodification.MemberMatcher.method;
import static org.powermock.api.support.membermodification.MemberModifier.replace;

import java.util.concurrent.atomic.AtomicInteger;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@PrepareForTest(Integer.class)
@RunWith(PowerMockRunner.class)
public class Ais123 {
    @Before
    public void before() {
        // "value" is just a place to store an incrementing integer
        AtomicInteger value = new AtomicInteger(1);
        replace(method(Integer.class, "intValue"))
            .with((proxy, method, args) -> value.getAndIncrement());
    }

    @Test
    public void test() {
        Integer a = 1;

        if (a == 1 && a == 2 && a == 3) {
            System.out.println("Success");
        } else {
            Assert.fail("(a == 1 && a == 2 && a == 3) != true, a = " + a.intValue());
        }
    }

}

由于这似乎是该JavaScript问题的后续内容，因此值得注意的是，该技巧和类似的用法也适用于Java：

public class Q48383521 {
    public static void main(String[] args) {
        int aﾠ = 1;
        int ﾠ2 = 3;
        int a = 3;
        if(aﾠ==1 && a==ﾠ2 && a==3) {
            System.out.println("success");
        }
    }
}

在Ideone上

但是请注意，这并不是使用Unicode可以做的最坏的事情。使用空格或控制字符（它们是有效的标识符部分）或使用看起来相同的不同字母仍会创建不同的标识符，并且可以将其识别出来，例如在进行文本搜索时。

但是这个程序

public class Q48383521 {
    public static void main(String[] args) {
        int ä = 1;
        int ä = 2;
        if(ä == 1 && ä == 2) {
            System.out.println("success");
        }
    }
}

至少从Unicode的角度来看，使用两个相同的标识符。他们只是用不同的方式来编码相同的字符ä，使用U+00E4和U+0061 U+0308。

在Ideone上

因此，根据您使用的工具的不同，它们可能不仅看起来相同，而且启用Unicode的文本工具甚至可能不会报告任何差异，在搜索时总是会找到两者。您甚至可能会遇到这样的问题，即在将源代码复制到其他人时，不同的表示形式会丢失，可能是试图获得“怪异行为”的帮助，从而使助手无法重现。

受@Erwin出色答案的启发，我写了一个类似的示例，但是使用Java Stream API。

有趣的是，我的解决方案有效，但是在极少数情况下（因为   just-in-time编译器会优化此类代码）。

诀窍是JIT使用以下VM选项禁用所有优化：

-Djava.compiler=NONE

在这种情况下，成功案例的数量将大大增加。这是代码：

class Race {
    private static int a;

    public static void main(String[] args) {
        IntStream.range(0, 100_000).parallel().forEach(i -> {
            a = 1;
            a = 2;
            a = 3;
            testValue();
        });
    }

    private static void testValue() {
        if (a == 1 && a == 2 && a == 3) {
            System.out.println("Success");
        }
    }
}

PS并行流ForkJoinPool在后台使用，变量a在多个线程之间共享而没有任何同步，这就是为什么结果不确定的原因。

沿着类似的线，通过由大量迫使浮子（或双）到下溢（或溢出）通过分裂（或乘法）：

int a = 1;
if (a / Float.POSITIVE_INFINITY == 1 / Float.POSITIVE_INFINITY
        && a / Float.POSITIVE_INFINITY == 2 / Float.POSITIVE_INFINITY
        && a / Float.POSITIVE_INFINITY == 3 / Float.POSITIVE_INFINITY) {
    System.out.println("Success");
}