Pode (a == 1 && a == 2 && a == 3) avaliar como verdadeiro em Java?

Sabemos que pode em JavaScript .

Mas é possível imprimir a mensagem "Success" na condição fornecida abaixo em Java?

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

Alguém sugeriu:

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

Mas, ao fazer isso, estamos alterando a variável real. Existe alguma outra maneira?

Sim, é muito fácil conseguir isso com vários threads, se você declarar variável acomo volátil.

Um segmento altera constantemente a variável a de 1 para 3, e outro segmento constantemente testa isso a == 1 && a == 2 && a == 3. Isso acontece com frequência suficiente para que um fluxo contínuo de "Sucesso" seja impresso no console.

(Observe que se você adicionar uma else {System.out.println("Failure");}cláusula, verá que o teste falha com muito mais frequência do que com êxito.)

Na prática, ele também funciona sem se declarar avolátil, mas apenas 21 vezes no meu MacBook. Sem volatile, o compilador ou o HotSpot pode armazenar em cache aou substituir a ifinstrução por if (false). Provavelmente, o HotSpot entra em ação depois de um tempo e o compila com instruções de montagem que armazenam o valor em cache a. Com volatile , ele continua imprimindo "Sucesso" para 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();
    }
}

Usando conceitos (e código) de uma brilhante resposta de código de golfe ,Integer valores podem ser alterados.

Nesse caso, ele pode fazer intcom que Integers seja igual a s quando normalmente não seriam:

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

Infelizmente, não é tão elegante quanto a resposta multithread de Erwin Bolwidt (como esta exige Integercasting) , mas ainda existem algumas travessuras divertidas.

Em esta questão @aioobe sugere (e aconselhar contra a) o uso de C pré-processador para classes Java.

Embora seja extremamente barato, essa é a minha solução:

#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 executado usando os seguintes comandos, ele produzirá exatamente um Success:

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

Como já sabemos que é possível fazer esse código ser avaliado como verdadeiro, graças às ótimas respostas de Erwin Bolwidt e phflack , eu queria mostrar que você precisa manter um alto nível de atenção ao lidar com uma condição semelhante à apresentada na pergunta, pois às vezes o que você vê pode não ser exatamente o que você pensa que é.

Esta é minha tentativa de mostrar que esse código é impresso Success!no console. Eu sei que trapacei um pouco , mas ainda acho que este é um bom lugar para apresentá-lo aqui.

Não importa quais sejam os objetivos de escrever um código como este - é melhor saber como lidar com a situação a seguir e como verificar se você não está errado com o que acha que vê.

Usei o cirílico 'a', que é um caractere distinto do latim 'a'. Você pode inspecionar os caracteres usados ​​na instrução if aqui .

Isso funciona porque os nomes das variáveis ​​são obtidos de diferentes alfabetos. Eles são identificadores distintos, criando duas variáveis ​​distintas com um valor diferente em cada uma.

Observe que, se você deseja que esse código funcione corretamente, a codificação de caracteres precisa ser alterada para uma que suporte os dois caracteres, por exemplo, todas as codificações Unicode (UTF-8, UTF-16 (em BE ou LE), UTF-32 e até UTF-7 ) ou Windows-1251, ISO 8859-5, KOI8-R (obrigado - Thomas Weller e Paŭlo Ebermann - por apontarem):

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

(Espero que você nunca precise lidar com esse tipo de problema em nenhum momento no futuro.)

Há outra maneira de abordar isso (além da abordagem volátil de corrida de dados que publiquei anteriormente), usando o poder do PowerMock. O PowerMock permite que os métodos sejam substituídos por outras implementações. Quando isso é combinado com o desempacotamento automático, a expressão original (a == 1 && a == 2 && a == 3), sem modificação, pode ser verdadeira.

A resposta do @ phflack depende da modificação do processo de boxe automático em Java que usa a Integer.valueOf(...)chamada. A abordagem abaixo depende da modificação do desbloqueio automático, alterando a Integer.intValue()chamada.

A vantagem da abordagem abaixo é que a declaração if original dada pelo OP na pergunta é usada inalterada, o que eu acho que é a mais 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());
        }
    }

}

Como esse parece ser um acompanhamento dessa pergunta sobre JavaScript , vale a pena notar que esse truque e similares também funcionam em 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");
        }
    }
}

Em Ideone

Mas observe que isso não é a pior coisa que você pode fazer com o Unicode. Usar espaços em branco ou caracteres de controle que sejam partes de identificadores válidos ou letras diferentes com a mesma aparência ainda cria identificadores diferentes e que podem ser identificados, por exemplo, ao fazer uma pesquisa de texto.

Mas esse programa

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

usa dois identificadores iguais, pelo menos do ponto de vista Unicode. Eles apenas usam maneiras diferentes de codificar o mesmo caractere ä, usando U+00E4e U+0061 U+0308.

Em Ideone

Portanto, dependendo da ferramenta que você está usando, elas podem não apenas parecer iguais, as ferramentas de texto habilitadas para Unicode podem até não reportar nenhuma diferença, sempre encontrando as duas ao pesquisar. Você pode até ter o problema de que as diferentes representações se percam ao copiar o código-fonte para outra pessoa, talvez tentando obter ajuda para o "comportamento estranho", tornando-o não reproduzível para o ajudante.

Inspirado na excelente resposta do @ Erwin , escrevi um exemplo semelhante, mas usando a API Java Stream .

E uma coisa interessante é que minha solução funciona, mas em casos muito raros (porque o   just-in-timecompilador otimiza esse código).

O truque é desativar as JITotimizações usando a seguinte VMopção:

-Djava.compiler=NONE

Nessa situação, o número de casos de sucesso aumenta significativamente. Aqui está o código:

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

Os fluxos paralelos PS são usados ForkJoinPoolsob o capô, e a variável a é compartilhada entre vários threads sem nenhuma sincronização, por isso o resultado é não determinístico.

Seguindo linhas semelhantes , forçando um flutuador (ou duplo) a estourar (ou estourar) através da divisão (ou multiplicação) por um grande número:

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