Czy (a == 1 && a == 2 && a == 3) może mieć wartość true w Javie?

Wiemy, że w JavaScript może .

Ale czy można wydrukować komunikat „Sukces” pod warunkiem podanym poniżej w Javie?

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

Ktoś zasugerował:

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

Ale robiąc to, zmieniamy rzeczywistą zmienną. Czy jest inny sposób?

Tak, jest to dość łatwe do osiągnięcia w przypadku wielu wątków, jeśli zadeklarujesz zmienną ajako zmienną.

Jeden wątek stale zmienia zmienną a z 1 na 3, a inny wątek stale to testuje a == 1 && a == 2 && a == 3. Wystarczająco często zdarza się, że na konsoli jest wyświetlany ciągły strumień „Sukces”.

(Zauważ, że jeśli dodasz else {System.out.println("Failure");}klauzulę, zobaczysz, że test kończy się niepowodzeniem znacznie częściej niż sukcesem).

W praktyce działa również bez deklarowania ajako niestabilny, ale tylko 21 razy na moim MacBooku. Bez volatiletego kompilator lub HotSpot mogą buforować alub zamieniać ifinstrukcję na if (false). Najprawdopodobniej HotSpot włącza się po chwili i kompiluje go do instrukcji asemblera, które buforują wartość a. Dzięki volatile temu drukuje „Sukces” na zawsze.

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

Używając pojęć (i kodu) z genialnej odpowiedzi w kodzie golfa , Integermożna zmylić wartości.

W tym przypadku może sprawić, że ints rzucone na Integers będą równe, podczas gdy normalnie nie byłyby:

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

Niestety nie jest tak elegancka, jak wielowątkowa odpowiedź Erwina Bolwidta (ponieważ ta wymaga Integerrzucania) , ale wciąż ma miejsce kilka zabawnych shenaniganów.

W tym pytaniu @aioobe sugeruje (i odradza) użycie preprocesora C dla klas Java.

Chociaż jest to wyjątkowo oszukańcze, to moje rozwiązanie:

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

Jeśli zostanie wykonany przy użyciu następujących poleceń, wyświetli dokładnie jedno Success:

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

Ponieważ już wiemy, że dzięki świetnym odpowiedziom Erwina Bolwidta i phflacka można sprawić, by ten kod był prawdziwy , chciałem pokazać, że należy zachować wysoki poziom uwagi, gdy mamy do czynienia ze stanem, który wygląda jak ten przedstawiony w pytaniu, ponieważ czasami to, co widzisz, może nie być dokładnie tym, o czym myślisz.

To jest moja próba pokazania, że ​​ten kod jest drukowany Success!na konsoli. Wiem, że trochę oszukiwałem , ale nadal uważam, że to dobre miejsce, aby to tutaj zaprezentować.

Bez względu na cel pisania takiego kodu - lepiej wiedzieć, jak postępować w następującej sytuacji i jak sprawdzić, czy nie mylisz się w tym, co myślisz, że widzisz.

Użyłem cyrylicy „a”, która jest znakiem odrębnym od łacińskiego „a”. Można badać znaki użyte w instrukcji if tutaj .

To działa, ponieważ nazwy zmiennych są pobierane z różnych alfabetów. Są to różne identyfikatory, tworzące dwie odrębne zmienne o innej wartości w każdej.

Zwróć uwagę, że jeśli chcesz, aby ten kod działał poprawnie, kodowanie znaków należy zmienić na obsługujące oba znaki, np. Wszystkie kodowania Unicode (UTF-8, UTF-16 (w BE lub LE), UTF-32, a nawet UTF-7 ) lub Windows-1251, ISO 8859-5, KOI8-R (dziękuję - Thomasowi Wellerowi i Paŭlo Ebermannowi - za wskazanie):

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

(Mam nadzieję, że nigdy nie będziesz musiał zajmować się tego rodzaju problemem w przyszłości.)

Istnieje inny sposób podejścia do tego (oprócz podejścia opartego na lotnych danych, które opublikowałem wcześniej), wykorzystując moc PowerMock. PowerMock umożliwia zastąpienie metod innymi implementacjami. W połączeniu z automatycznym rozpakowywaniem oryginalne wyrażenie (a == 1 && a == 2 && a == 3), bez modyfikacji, może być prawdziwe.

Odpowiedź @ phflack polega na zmodyfikowaniu procesu auto-boxingu w Javie, który używa Integer.valueOf(...)wywołania. Poniższe podejście polega na zmodyfikowaniu automatycznego rozpakowywania poprzez zmianę Integer.intValue()połączenia.

Zaletą poniższego podejścia jest to, że oryginalne stwierdzenie if podane przez PO w pytaniu jest używane bez zmian, co uważam za najbardziej eleganckie.

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

}

Ponieważ wydaje się, że jest to kontynuacja tego pytania JavaScript , warto zauważyć, że ta sztuczka i podobne działają również w Javie:

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

Na Ideone

Ale pamiętaj, że nie jest to najgorsza rzecz, jaką możesz zrobić z Unicode. Użycie białych znaków lub znaków sterujących, które są prawidłowymi częściami identyfikatora lub użycie różnych liter, które wyglądają tak samo, nadal tworzy identyfikatory, które są różne i można je zauważyć, np. Podczas wyszukiwania tekstu.

Ale ten program

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

używa dwóch identycznych identyfikatorów, przynajmniej z punktu widzenia Unicode. Po prostu używają różnych sposobów kodowania tego samego znaku ä, używając U+00E4i U+0061 U+0308.

Na Ideone

W zależności od używanego narzędzia mogą nie tylko wyglądać tak samo, narzędzia tekstowe z obsługą Unicode mogą nawet nie zgłaszać żadnej różnicy, zawsze znajdując oba podczas wyszukiwania. Możesz nawet mieć problem z tym, że różne reprezentacje giną podczas kopiowania kodu źródłowego komuś innemu, być może próbując uzyskać pomoc dotyczącą „dziwnego zachowania”, uniemożliwiając jego odtworzenie dla osoby pomagającej.

Zainspirowany doskonałą odpowiedzią @ Erwin , napisałem podobny przykład, ale używając Java Stream API .

Ciekawostką jest to, że moje rozwiązanie działa, ale w bardzo rzadkich przypadkach (bo   just-in-timekompilator optymalizuje taki kod).

Sztuczka polega na wyłączeniu wszelkich JIToptymalizacji za pomocą następującej VMopcji:

-Djava.compiler=NONE

W tej sytuacji liczba przypadków sukcesu znacznie wzrasta. Oto kod:

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 Równoległe strumienie są używane ForkJoinPoolpod maską, a zmienna a jest współdzielona między wieloma wątkami bez żadnej synchronizacji, dlatego wynik jest niedeterministyczny.

Wzdłuż podobnych linii , zmuszając pływak (lub podwójny) do niedomiaru (lub przepełnienia) przez dzielenie (lub mnożenie) przez dużą liczbę:

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