Может ли (a == 1 && a == 2 && a == 3) иметь значение true в Java?

Мы знаем, что это возможно в 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.

Один поток постоянно меняет переменную от 1 до 3, а другой поток постоянно проверяет это a == 1 && a == 2 && a == 3. Это происходит достаточно часто, чтобы на консоли печатался непрерывный поток «Success».

(Обратите внимание, что если вы добавите else {System.out.println("Failure");}предложение, вы увидите, что тест проваливается гораздо чаще, чем успешно.)

На практике это также работает, не объявляя aкак изменчивый, но только 21 раз на моем MacBook. Без 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 приведенным к Integers равным, когда они обычно не будут:

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");
    }
}

К сожалению, он не так элегантен, как многопоточный ответ Эрвина Болвидта (так как этот требует Integerкастинга) , но все же происходят некоторые забавные махинации.

В этом вопросе @aioobe предлагает (и не советует) использовать препроцессор Си для классов Java.

Хотя это очень обманчиво, это мое решение:

#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

Так как мы уже знаем, что этот код можно сделать истинным благодаря отличным ответам Эрвина Болвидта и phflack , я хотел показать, что вам нужно сохранять высокий уровень внимания при работе с условием, похожим на приведенное в вопросе, так как иногда то, что вы видите, может быть не совсем тем, что вы думаете.

Это моя попытка показать, что этот код печатается Success!на консоли. Я знаю, что немного обманул , но я все еще думаю, что это хорошее место, чтобы представить это прямо здесь.

Неважно, каковы цели написания подобного кода - лучше знать, как справиться со следующей ситуацией и как проверить, не ошибаетесь ли вы с тем, что, по вашему мнению, вы видите.

Я использовал кириллицу «а», которая отличается от латинского «а». Вы можете просмотреть символы, используемые в операторе if здесь .

Это работает, потому что имена переменных взяты из разных алфавитов. Это разные идентификаторы, создающие две разные переменные с разными значениями в каждой.

Обратите внимание, что если вы хотите, чтобы этот код работал должным образом, кодировку символов необходимо изменить на кодировку, поддерживающую оба символа, например все кодировки Unicode (UTF-8, UTF-16 (в BE или LE), UTF-32, даже UTF-7). ) или Windows-1251, ISO 8859-5, KOI8-R (спасибо - Томас Веллер и Паŭло Эберманн - за указание на это):

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, который использует Integer.valueOf(...)вызов. Приведенный ниже подход основан на изменении автоматической распаковки путем изменения Integer.intValue()вызова.

Преимущество подхода, приведенного ниже, состоит в том, что исходное выражение if, данное OP в этом вопросе, используется без изменений, что я считаю наиболее элегантным.

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");
        }
    }
}

По идоне

Но учтите, что это не самое худшее, что вы можете сделать с 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.

По идоне

Поэтому, в зависимости от используемого вами инструмента, они могут не только выглядеть одинаково, текстовые инструменты с поддержкой 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 совместно используется несколькими потоками без какой-либо синхронизации, поэтому результат является недетерминированным.

В том же ключе , заставляя float (или double) потерять (или переполнить) с помощью деления (или умножения) на большое число:

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");
}