(A == 1 && a == 2 && a == 3) può essere valutato come vero in Java?

Sappiamo che può in JavaScript .

Ma è possibile stampare il messaggio "Success" sulla condizione indicata di seguito in Java?

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

Qualcuno ha suggerito:

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

Ma facendo questo stiamo cambiando la variabile reale. C'è un altro modo?

Sì, è abbastanza facile ottenerlo con più thread, se si dichiara variabile acome volatile.

Un thread cambia costantemente la variabile a da 1 a 3 e un altro thread lo verifica costantemente a == 1 && a == 2 && a == 3. Capita spesso di avere un flusso continuo di "Success" stampato sulla console.

(Nota se aggiungi una else {System.out.println("Failure");}clausola, vedrai che il test fallisce molto più spesso di quanto non riesca.)

In pratica, funziona anche senza dichiararsi avolatile, ma solo 21 volte sul mio MacBook. Senza volatile, al compilatore o HotSpot è consentito memorizzare nella cache ao sostituire l' ifistruzione if (false). Molto probabilmente, HotSpot entra in funzione dopo un po 'e lo compila in istruzioni di assemblaggio che memorizzano nella cache il valore di a. Con volatile , continua a stampare "Successo" per sempre.

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

Utilizzando i concetti (e il codice) di una brillante risposta di golf del codice , i Integervalori possono essere confusi.

In questo caso, può fare in modo che ints lanciate Integersiano uguali quando normalmente non sarebbero:

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

Sfortunatamente non è così elegante come la risposta multithread di Erwin Bolwidt (poiché questa richiede il Integercasting) , ma si svolgono comunque alcuni divertenti shenanigans.

In questa domanda @aioobe suggerisce (e sconsiglia) l'uso del preprocessore C per le classi Java.

Sebbene sia estremamente economico, questa è la mia soluzione:

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

Se eseguito utilizzando i seguenti comandi, ne verrà generato esattamente uno Success:

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

Poiché sappiamo già che è possibile fare in modo che questo codice valuti il ​​vero grazie alle grandi risposte di Erwin Bolwidt e phflack , ho voluto dimostrare che è necessario mantenere un alto livello di attenzione quando si ha a che fare con una condizione che assomiglia a quella presentata nella domanda, come a volte ciò che vedi potrebbe non essere esattamente quello che pensi che sia.

Questo è il mio tentativo di dimostrare che questo codice viene stampato Success!sulla console. So di aver tradito un po ' , ma penso ancora che sia un buon posto per presentarlo proprio qui.

Non importa quali siano gli scopi di scrivere codice come questo: meglio sapere come affrontare la seguente situazione e come verificare se non ti sbagli con ciò che pensi di vedere.

Ho usato il cirillico "a", che è un carattere distinto dal latino "a". Puoi controllare i caratteri usati nell'istruzione if qui .

Questo funziona perché i nomi delle variabili sono presi da diversi alfabeti. Sono identificatori distinti, creando due variabili distinte con un valore diverso in ciascuna.

Nota che se vuoi che questo codice funzioni correttamente, la codifica dei caratteri deve essere cambiata in una che supporti entrambi i caratteri, ad es. Tutte le codifiche Unicode (UTF-8, UTF-16 (in BE o LE), UTF-32, persino UTF-7 ) o Windows-1251, ISO 8859-5, KOI8-R (grazie - Thomas Weller e Paŭlo Ebermann - per averlo sottolineato):

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

(Spero che in futuro non dovrai mai affrontare questo tipo di problema.)

Esiste un altro modo per affrontarlo (oltre all'approccio volatile di data racing che ho pubblicato in precedenza), utilizzando la potenza di PowerMock. PowerMock consente di sostituire i metodi con altre implementazioni. Se combinato con l'auto-unboxing, l'espressione originale (a == 1 && a == 2 && a == 3), senza modifiche, può essere resa vera.

La risposta di @ phflack si basa sulla modifica del processo di auto-boxing in Java che utilizza la Integer.valueOf(...)chiamata. L'approccio seguente si basa sulla modifica del disinserimento automatico mediante modifica della Integer.intValue()chiamata.

Il vantaggio dell'approccio di seguito è che l'istruzione if originale fornita dall'OP nella domanda viene utilizzata invariata, che ritengo sia la più elegante.

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

}

Poiché questo sembra essere un seguito di questa domanda JavaScript , vale la pena notare che questo trucco e simili funzionano anche in 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");
        }
    }
}

Su Ideone

Ma nota che questa non è la cosa peggiore che potresti fare con Unicode. Uso di spazi vuoti o caratteri di controllo che sono parti di identificatori validi o lettere diverse che sembrano uguali crea ancora identificatori diversi e che possono essere individuati, ad esempio quando si esegue una ricerca di testo.

Ma questo programma

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

utilizza due identificatori uguali, almeno dal punto di vista Unicode. Usano solo modi diversi per codificare lo stesso personaggio ä, usando U+00E4e U+0061 U+0308.

Su Ideone

Quindi, a seconda dello strumento che stai utilizzando, potrebbero non solo avere lo stesso aspetto, ma gli strumenti di testo abilitati Unicode potrebbero non segnalare alcuna differenza, trovando sempre entrambi durante la ricerca. Potresti anche avere il problema che le diverse rappresentazioni si perdono durante la copia del codice sorgente a qualcun altro, forse cercando di ottenere aiuto per il "comportamento strano", rendendolo non riproducibile per l'helper.

Ispirato dall'ottima risposta di @Erwin , ho scritto un esempio simile, ma utilizzando l' API Java Stream .

E una cosa interessante è che la mia soluzione funziona, ma in casi molto rari (perché il   just-in-timecompilatore ottimizza tale codice).

Il trucco è disabilitare tutte le JITottimizzazioni usando la seguente VMopzione:

-Djava.compiler=NONE

In questa situazione, il numero di casi di successo aumenta in modo significativo. Ecco il codice:

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 I flussi paralleli vengono utilizzati ForkJoinPoolsotto il cofano e la variabile a viene condivisa tra più thread senza alcuna sincronizzazione, ecco perché il risultato non è deterministico.

Lungo linee simili , forzando un float (o double) a underflow (o overflow) attraverso la divisione (o moltiplicazione) per un numero elevato:

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