Kann (a == 1 && a == 2 && a == 3) in Java als wahr ausgewertet werden?

Wir wissen, dass dies in JavaScript möglich ist .

Aber ist es möglich, die Meldung "Erfolg" unter der unten angegebenen Bedingung in Java zu drucken?

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

Jemand schlug vor:

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

Auf diese Weise ändern wir jedoch die tatsächliche Variable. Gibt es einen anderen Weg?

Ja, es ist ziemlich einfach, dies mit mehreren Threads zu erreichen, wenn Sie die Variable aals flüchtig deklarieren .

Ein Thread ändert ständig die Variable a von 1 auf 3, und ein anderer Thread testet dies ständig a == 1 && a == 2 && a == 3. Es kommt oft genug vor, dass ein kontinuierlicher Stream von "Success" auf der Konsole gedruckt wird.

(Wenn Sie eine else {System.out.println("Failure");}Klausel hinzufügen , werden Sie feststellen, dass der Test weitaus häufiger fehlschlägt als erfolgreich.)

In der Praxis funktioniert es auch, ohne es aals flüchtig zu deklarieren , aber nur 21 Mal auf meinem MacBook. Ohne volatiledarf der Compiler oder HotSpot adie ifAnweisung zwischenspeichern oder durch ersetzen if (false). Höchstwahrscheinlich wird HotSpot nach einer Weile aktiviert und zu Assembly-Anweisungen kompiliert, die den Wert von zwischenspeichern a. Mit volatile druckt es "Erfolg" für immer.

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

Mit Konzepten (und Code) aus einer brillanten Code-Golf-Antwort können IntegerWerte durcheinander gebracht werden.

In diesem Fall kann ints gegossen werden, Integerum gleich zu sein, wenn dies normalerweise nicht der Fall wäre:

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

Leider ist es nicht ganz so elegant wie Erwin Bolwidts Multithread-Antwort (da diese ein IntegerCasting erfordert ) , aber es finden trotzdem einige lustige Spielereien statt.

In dieser Frage schlägt @aioobe die Verwendung des C-Präprozessors für Java-Klassen vor (und rät davon ab).

Obwohl es extrem betrügerisch ist, ist das meine Lösung:

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

Bei Ausführung mit den folgenden Befehlen wird genau einer ausgegeben Success:

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

Da wir bereits wissen, dass es dank der großartigen Antworten von Erwin Bolwidt und phflack möglich ist , diesen Code als wahr auszuwerten , wollte ich zeigen, dass Sie bei der Behandlung einer Bedingung, die wie die vorgestellte aussieht, ein hohes Maß an Aufmerksamkeit auf sich ziehen müssen in der Frage, da manchmal das, was Sie sehen, möglicherweise nicht genau das ist, was Sie denken, dass es ist.

Dies ist mein Versuch zu zeigen, dass dieser Code Success!auf der Konsole gedruckt wird. Ich weiß, dass ich ein bisschen geschummelt habe , aber ich denke immer noch, dass dies ein guter Ort ist, um es hier zu präsentieren.

Egal, wozu das Schreiben von Code wie diesen dient - es ist besser zu wissen, wie man mit der folgenden Situation umgeht und wie man prüft, ob man mit dem, was man zu sehen glaubt, nicht falsch liegt.

Ich habe das kyrillische 'a' verwendet, das sich vom lateinischen 'a' unterscheidet. Sie können die in der if-Anweisung verwendeten Zeichen hier überprüfen .

Dies funktioniert, weil die Namen der Variablen aus verschiedenen Alphabeten stammen. Sie sind unterschiedliche Bezeichner, wodurch zwei unterschiedliche Variablen mit jeweils unterschiedlichen Werten erstellt werden.

Beachten Sie, dass, wenn dieser Code ordnungsgemäß funktionieren soll, die Zeichenkodierung in eine geändert werden muss, die beide Zeichen unterstützt, z. B. alle Unicode-Kodierungen (UTF-8, UTF-16 (in BE oder LE), UTF-32, sogar UTF-7) ) oder Windows-1251, ISO 8859-5, KOI8-R (danke - Thomas Weller und Paŭlo Ebermann - für den Hinweis):

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

(Ich hoffe, Sie werden sich in Zukunft nie mehr mit solchen Problemen befassen müssen.)

Es gibt eine andere Möglichkeit, dies zu erreichen (zusätzlich zu dem zuvor veröffentlichten Ansatz für flüchtige Datenrennen), bei dem PowerMock verwendet wird. Mit PowerMock können Methoden durch andere Implementierungen ersetzt werden. Wenn dies mit dem automatischen Entpacken kombiniert wird, kann der ursprüngliche Ausdruck (a == 1 && a == 2 && a == 3)ohne Änderung wahr gemacht werden.

Die Antwort von @ phflack basiert auf der Änderung des Auto-Boxing-Prozesses in Java, der den Integer.valueOf(...)Aufruf verwendet. Der folgende Ansatz basiert auf dem Ändern des automatischen Entpackens durch Ändern des Integer.intValue()Anrufs.

Der Vorteil des folgenden Ansatzes besteht darin, dass die ursprüngliche if-Anweisung des OP in der Frage unverändert verwendet wird, was ich für die eleganteste halte.

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

}

Da dies eine Fortsetzung dieser JavaScript-Frage zu sein scheint , ist es erwähnenswert, dass dieser Trick und ähnliches auch in Java funktioniert:

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

Auf Ideone

Beachten Sie jedoch, dass dies nicht das Schlimmste ist, was Sie mit Unicode tun können. Wenn Sie Leerzeichen oder Steuerzeichen verwenden, die gültige Bezeichnerteile sind, oder verschiedene Buchstaben verwenden, die gleich aussehen, werden immer noch Bezeichner erstellt, die unterschiedlich sind und erkannt werden können, z. B. bei einer Textsuche.

Aber dieses Programm

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

verwendet zwei Bezeichner, die zumindest aus Unicode-Sicht identisch sind. Sie verwenden nur verschiedene Methoden, um dasselbe Zeichen ämit U+00E4und zu codieren U+0061 U+0308.

Auf Ideone

Je nachdem, welches Tool Sie verwenden, sehen sie möglicherweise nicht nur gleich aus. Unicode-fähige Textwerkzeuge melden möglicherweise nicht einmal einen Unterschied und finden bei der Suche immer beide. Möglicherweise haben Sie sogar das Problem, dass die verschiedenen Darstellungen beim Kopieren des Quellcodes auf eine andere Person verloren gehen und möglicherweise versuchen, Hilfe für das „seltsame Verhalten“ zu erhalten, wodurch es für den Helfer nicht reproduzierbar wird.

Inspiriert von der hervorragenden Antwort von @ Erwin habe ich ein ähnliches Beispiel geschrieben, aber die Java Stream API verwendet .

Und eine interessante Sache ist, dass meine Lösung funktioniert, aber in sehr seltenen Fällen (weil der   just-in-timeCompiler einen solchen Code optimiert).

Der Trick besteht darin, JITOptimierungen mit der folgenden VMOption zu deaktivieren :

-Djava.compiler=NONE

In dieser Situation steigt die Anzahl der Erfolgsfälle erheblich an. Hier ist der Code:

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 Parallele Streams werden ForkJoinPoolunter der Haube verwendet, und die Variable a wird ohne Synchronisation von mehreren Threads gemeinsam genutzt. Deshalb ist das Ergebnis nicht deterministisch.

In ähnlicher Weise , indem ein Float (oder Double) durch Division (oder Multiplikation) durch eine große Zahl zum Unterlauf (oder Überlauf) gezwungen wird:

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