Criando um operador "lógico exclusivo ou" em Java

Observações:

Java possui um operador AND lógico.
Java possui um operador OR lógico.
Java possui um operador NOT lógico.

Problema:

Java não possui um operador XOR lógico, de acordo com a sun . Eu gostaria de definir um.

Definição do método:

Como método, é simplesmente definido da seguinte forma:

public static boolean logicalXOR(boolean x, boolean y) {
    return ( ( x || y ) && ! ( x && y ) );
}

Chamada de método:

Este método é chamado da seguinte maneira:

boolean myVal = logicalXOR(x, y);

Uso do Operador:

Eu preferiria ter um operador, usado da seguinte maneira:

boolean myVal = x ^^ y;

Questão:

Não consigo encontrar nada sobre como definir um novo operador em Java. Por onde devo começar?

Java tem um operador XOR lógico , é ^ (como em a ^ b).

Além disso, você não pode definir novos operadores em Java.

Edit: Aqui está um exemplo:

public static void main(String[] args) {
    boolean[] all = { false, true };
    for (boolean a : all) {
        for (boolean b: all) {
            boolean c = a ^ b;
            System.out.println(a + " ^ " + b + " = " + c);
        }
    }
}

Resultado:

false ^ false = false
false ^ true = true
verdadeiro ^ falso = verdadeiro
verdadeiro ^ verdadeiro = falso

Não é x! = Y?

Java possui um operador AND lógico.
Java possui um operador OR lógico.

Errado.

Java tem

• dois operadores AND lógicos: AND normal é & e curto-circuito AND é &&, e
• dois operadores OR lógicos: OR normal é | e curto-circuito OU é ||.

O XOR existe apenas como ^, porque a avaliação de curto-circuito não é possível.

Talvez você tenha entendido mal a diferença entre &and &&, |e || O objetivo dos operadores de atalho &&e ||é que o valor do primeiro operando possa determinar o resultado e, portanto, o segundo operando não precise ser avaliado.

Isso é especialmente útil se o segundo operando resultar em um erro. por exemplo

if (set == null || set.isEmpty())
// or
if (list != null && list.size() > 0)

No entanto, com o XOR , você sempre deve avaliar o segundo operando para obter o resultado, portanto a única operação significativa é ^.

Você pode escrever (a!=b)

Isso funcionaria da mesma maneira que a ^ b.

Isso ocorre porque a sobrecarga do operador é algo que eles especificamente deixaram deliberadamente fora do idioma. Eles "trapacearam" um pouco com a concatenação de strings, mas além disso, essa funcionalidade não existe.

(aviso de isenção de responsabilidade: não trabalhei com os últimos dois grandes lançamentos de java, por isso, se estiver disponível agora, ficarei muito surpreso)

O único operador que sobrecarrega em Java é + em Strings ( JLS 15.18.1 String Concatenation Operator + ).

A comunidade foi dividida em três por anos, 1/3 não o quer, 1/3 o quer e 1/3 não se importa.

Você pode usar o unicode para criar nomes de métodos que são símbolos ... portanto, se você tiver um símbolo que deseja usar, poderá fazer myVal = x. $ (Y); onde $ é o símbolo ex não é um primitivo ... mas isso vai ser desonesto em alguns editores e é limitado, pois você não pode fazer isso em um primitivo.

A seguir, seu código:

public static boolean logicalXOR(boolean x, boolean y) {
    return ( ( x || y ) && ! ( x && y ) );
}

é supérfluo.

Por que não escrever:

public static boolean logicalXOR(boolean x, boolean y) {
    return x != y;
}

?

Além disso, como javashlook disse , já existe ^operador.

!=e ^trabalhe de forma idêntica * para operandos booleanos (seu caso), mas de maneira diferente para operandos inteiros.

<sub>* Notas:
1. Eles funcionam de forma idêntica para operandos boolean(tipo primitivo), mas não Boolean(tipo de objeto). Os Booleanvalores (tipo de objeto) podem ter valor null. E !=retornará falseou truequando um ou ambos os seus operandos estiverem null, enquanto ^lançará NullPointerExceptionneste caso.
2. Embora funcionem de forma idêntica, eles têm precedência diferente, por exemplo, quando usados ​​com &: a & b != c & dserão tratados como a & (b != c) & d, enquanto a & b ^ c & dserão tratados como (a & b) ^ (c & d)(offtopic: ai, tabela de precedência no estilo C é uma porcaria).</sub>

Aqui está um método XOR var arg para java ...

public static boolean XOR(boolean... args) {
  boolean r = false;
  for (boolean b : args) {
    r = r ^ b;
  }
  return r;
}

Aproveitar

Exclusivo lógico - ou em Java é chamado !=. Você também pode usar ^se quiser confundir seus amigos.

Você pode usar o Xtend (operadores infix e sobrecarga de operadores) para sobrecarregar os operadores e 'permanecer' em Java

O que você está pedindo não faria muito sentido. A menos que eu esteja incorreto, você está sugerindo que deseja usar o XOR para executar operações lógicas da mesma forma que AND e OR. Seu código fornecido realmente mostra o que estou me referindo:

public static boolean logicalXOR(boolean x, boolean y) {
    return ( ( x || y ) && ! ( x && y ) );
}

Sua função possui entradas booleanas e, quando o XOR bit a bit é usado em booleanos, o resultado é o mesmo que o código que você forneceu. Em outras palavras, o XOR bit a bit já é eficiente na comparação de bits individuais (booleanos) ou na comparação de bits individuais em valores maiores. Para colocar isso em contexto, em termos de valores binários, qualquer valor diferente de zero é TRUE e apenas ZERO é falso.

Portanto, para que o XOR seja aplicado da mesma forma que Logical AND é aplicado, você usaria apenas valores binários com apenas um bit (fornecendo o mesmo resultado e eficiência) ou o valor binário teria que ser avaliado como um todo, em vez de por bit. Em outras palavras, a expressão (010 ^^ 110) = FALSE em vez de (010 ^^ 110) = 100. Isso removeria a maior parte do significado semântico da operação e representa um teste lógico que você não deve usar de qualquer maneira.

A e B teriam que ser valores booleanos para fazer! = O mesmo que xor, para que a tabela verdade tivesse a mesma aparência. Você também pode usar! (A == B) lol.

Estou usando a classe muito popular "org.apache.commons.lang.BooleanUtils"

Este método é testado por muitos usuários e seguro. Diverta-se. Uso:

boolean result =BooleanUtils.xor(new boolean[]{true,false});

Como o tipo de dados booleano é armazenado como um número inteiro, o operador de bit ^ funciona como uma operação XOR se usado com valores booleanos.

//©Mfpl - XOR_Test.java

    public class XOR_Test {
        public static void main (String args[]) {
            boolean a,b;

            a=false; b=false;
            System.out.println("a=false; b=false;  ->  " + (a^b));

            a=false; b=true;
            System.out.println("a=false; b=true;  ->  " + (a^b));

            a=true;  b=false;
            System.out.println("a=true;  b=false;  ->  " + (a^b));

            a=true; b=true;
            System.out.println("a=true; b=true;  ->  " + (a^b));

            /*  output of this program:
                    a=false; b=false;  ->  false
                    a=false; b=true;  ->  true
                    a=true;  b=false;  ->  true
                    a=true; b=true;  ->  false
            */
        }
    }

Aqui está um exemplo:

Dados 2 valores int, retorne true se um for negativo e outro for positivo. Exceto se o parâmetro "negativo" for verdadeiro, retorne verdadeiro somente se ambos forem negativos.

    public boolean posNeg(int a, int b, boolean negative) {
      if(!negative){
        return (a>0 && b<0)^(b>0 && a<0);
      }
      else return (a<0 && b<0);
    }

você precisará mudar para o Scala para implementar seus próprios operadores

exemplo de tubo