(A == 1 && a == 2 && a == 3) peut-il être évalué à vrai en Java?

Nous savons que c'est possible en JavaScript .

Mais est-il possible d'imprimer le message "Success" à la condition donnée ci-dessous en Java?

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

Quelqu'un a suggéré:

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

Mais en faisant cela, nous modifions la variable réelle. Est-ce qu'il y a un autre moyen?

Oui, il est assez facile d'y parvenir avec plusieurs threads, si vous déclarez la variable acomme volatile.

Un thread change constamment la variable a de 1 à 3, et un autre thread le teste constamment a == 1 && a == 2 && a == 3. Il arrive assez souvent d'avoir un flux continu de "Succès" imprimé sur la console.

(Notez que si vous ajoutez une else {System.out.println("Failure");}clause, vous verrez que le test échoue beaucoup plus souvent qu'il ne réussit.)

En pratique, cela fonctionne également sans se déclarer avolatile, mais seulement 21 fois sur mon MacBook. Sans volatile, le compilateur ou HotSpot est autorisé à mettre en cache aou à remplacer l' ifinstruction par if (false). Très probablement, HotSpot démarre après un certain temps et le compile en instructions d'assemblage qui mettent en cache la valeur de a. Avec volatile , il continue à imprimer "Success" pour toujours.

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

En utilisant les concepts (et le code) d'une réponse brillante au code de golf , les Integervaleurs peuvent être perturbées.

Dans ce cas, cela peut rendre ints castés Integerégaux alors qu'ils ne le seraient pas normalement:

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

Malheureusement, ce n'est pas aussi élégant que la réponse multithread d'Erwin Bolwidt (car celle-ci nécessite un Integercasting) , mais des manigances amusantes ont toujours lieu.

Dans cette question, @aioobe suggère (et déconseille) l'utilisation du préprocesseur C pour les classes Java.

Bien que ce soit extrêmement triche, c'est ma solution:

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

S'il est exécuté à l'aide des commandes suivantes, il en produira exactement une Success:

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

Comme nous le savons déjà, il est possible de rendre ce code évalué à vrai grâce aux excellentes réponses d' Erwin Bolwidt et phflack , je voulais montrer que vous devez garder un haut niveau d'attention lorsque vous traitez avec une condition qui ressemble à celle présentée dans la question, car parfois ce que vous voyez n'est peut-être pas exactement ce que vous pensez.

C'est ma tentative pour montrer que ce code s'imprime Success!sur la console. Je sais que j'ai un peu triché , mais je pense toujours que c'est un bon endroit pour le présenter ici.

Quels que soient les objectifs d'écrire un code comme celui-ci, il vaut mieux savoir comment gérer la situation suivante et comment vérifier si vous ne vous trompez pas avec ce que vous pensez voir.

J'ai utilisé le cyrillique «a» qui est un caractère distinct du latin «a». Vous pouvez inspecter les caractères utilisés dans l'instruction if ici .

Cela fonctionne car les noms des variables proviennent de différents alphabets. Ce sont des identifiants distincts, créant deux variables distinctes avec une valeur différente dans chacune.

Notez que si vous voulez que ce code fonctionne correctement, le codage des caractères doit être remplacé par un codage prenant en charge les deux caractères, par exemple tous les codages Unicode (UTF-8, UTF-16 (en BE ou LE), UTF-32, même UTF-7 ), ou Windows-1251, ISO 8859-5, KOI8-R (merci - Thomas Weller et Paŭlo Ebermann - de l'avoir signalé):

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

(J'espère que vous n'aurez plus jamais à faire face à ce genre de problème à l'avenir.)

Il existe une autre façon d'aborder cela (en plus de l'approche de course de données volatile que j'ai publiée plus tôt), en utilisant la puissance de PowerMock. PowerMock permet de remplacer les méthodes par d'autres implémentations. Lorsque cela est combiné avec le déballage automatique, l'expression d'origine (a == 1 && a == 2 && a == 3), sans modification, peut être rendue vraie.

La réponse de @ phflack repose sur la modification du processus d'auto-boxing en Java qui utilise l' Integer.valueOf(...)appel. L'approche ci-dessous repose sur la modification du déballage automatique en modifiant l' Integer.intValue()appel.

L'avantage de l'approche ci-dessous est que l'instruction if originale donnée par l'OP dans la question est utilisée sans changement, ce qui est à mon avis le plus élégant.

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

}

Puisque cela semble être un suivi de cette question JavaScript , il convient de noter que cette astuce et d'autres fonctionnent également en 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");
        }
    }
}

Sur Ideone

Mais notez que ce n'est pas la pire chose que vous puissiez faire avec Unicode. L'utilisation d'espaces blancs ou de caractères de contrôle qui sont des parties d'identifiants valides ou l' utilisation de lettres différentes qui se ressemblent crée toujours des identifiants différents et qui peuvent être repérés, par exemple lors d'une recherche de texte.

Mais ce programme

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

utilise deux identificateurs identiques, au moins du point de vue Unicode. Ils utilisent simplement différentes manières pour encoder le même caractère ä, en utilisant U+00E4et U+0061 U+0308.

Sur Ideone

Ainsi, en fonction de l'outil que vous utilisez, ils peuvent non seulement se ressembler, mais les outils de texte compatibles Unicode peuvent même ne pas signaler de différence, trouvant toujours les deux lors de la recherche. Vous pouvez même avoir le problème que les différentes représentations se perdent lors de la copie du code source à quelqu'un d'autre, essayant peut-être d'obtenir de l'aide pour le «comportement étrange», le rendant non reproductible pour l'assistant.

Inspiré par l'excellente réponse de @ Erwin , j'ai écrit un exemple similaire, mais en utilisant l' API Java Stream .

Et une chose intéressante est que ma solution fonctionne, mais dans de très rares cas (car le   just-in-timecompilateur optimise un tel code).

L'astuce consiste à désactiver toutes les JIToptimisations à l'aide de l' VMoption suivante :

-Djava.compiler=NONE

Dans cette situation, le nombre de cas de réussite augmente considérablement. Voici le 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 Les flux parallèles utilisent ForkJoinPoolsous le capot, et la variable a est partagée entre plusieurs threads sans aucune synchronisation, c'est pourquoi le résultat est non déterministe.

Dans le même ordre d'idées , en forçant un flottant (ou double) à déborder (ou à déborder) par division (ou multiplication) par un grand nombre:

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