operador - ternary operator java

Creación de un operador "lógico exclusivo o" en Java

Question

Observaciones:

Java tiene un operador lógico AND
Java tiene un operador OR lógico.
Java tiene un operador lógico NO.

Problema:

Java no tiene un operador XOR lógico, según sun . Me gustaría definir uno.

Definición del método:

Como método se define simplemente como sigue:

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

Método de llamada:

Este método se llama de la siguiente manera:

boolean myVal = logicalXOR(x, y);

Uso del operador:

Preferiría mucho tener un operador, utilizado de la siguiente manera:

boolean myVal = x ^^ y;

Pregunta:

No puedo encontrar nada sobre cómo definir un nuevo operador en Java. ¿Donde debería empezar?

Answer 1

Java tiene un operador lógico AND
Java tiene un operador OR lógico.

Incorrecto.

Java tiene

• dos operadores AND lógicos: AND normal es & y cortocircuito AND es &&, y
• dos operadores lógicos OR: OR normal es | y el cortocircuito O es ||.

XOR existe solo como ^, porque la evaluación de cortocircuito no es posible.

Answer 2

¿No es x! = Y?

Answer 3

A y B tendrían que ser valores booleanos para hacer! = Igual que xor para que la tabla de verdad se vea igual. También puedes usar! (A == B) lol.

Answer 4

Aquí hay un ejemplo:

Dados 2 valores int, devuelva verdadero si uno es negativo y uno es positivo. Excepto si el parámetro "negativo" es verdadero, entonces devuelva verdadero solo si ambos son 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);
    }

Answer 5

Aquí hay un método var XOR arg para Java ...

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

Disfrutar

Answer 6

Debido a que el tipo de datos booleano se almacena como un entero, el operador de bit ^ funciona como una operación XOR si se usa con 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
            */
        }
    }

Answer 7

El único operador que sobrecarga en Java es + en Cadenas ( JLS 15.18.1 Operador de concatenación de cadenas + ).

La comunidad se ha dividido en 3 por años, 1/3 no lo quiere, 1/3 lo quiere y 1/3 no le importa.

Puede usar Unicode para crear nombres de métodos que sean símbolos ... así que si tiene un símbolo que quiere usar, podría hacer myVal = x. $ (Y); donde $ es el símbolo y x no es un primitivo ... pero eso va a ser dudoso en algunos editores y es limitante ya que no se puede hacer con un primitivo.

Answer 8

El siguiente tu código:

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

es superfluo

¿Por qué no escribir:

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

?

Además, como said javashlook, ya hay un operador.

!= y ^ funcionan de forma idéntica * para operandos booleanos (su caso), pero de manera diferente para operandos enteros.

<sub>* Notas:
1. Funcionan de forma idéntica para los operandos boolean (tipo primitivo), pero no Boolean (tipo de objeto). Como valores Boolean (tipo de objeto) pueden tener valor null . Y != Devolverá false o true cuando uno o ambos de sus operandos sean null , mientras que ^ lanzará NullPointerException en este caso.
2. Aunque funcionan de manera idéntica, tienen diferentes precedencias, por ejemplo, cuando se usan con & : a & b != c & d se tratarán como a & (b != c) & d , mientras que a & b ^ c & d harán ser tratado como (a & b) ^ (c & d) (offtopic: ouch, la tabla de precedencia de estilo C apesta).</sub>

Answer 9

Esto se debe a que la sobrecarga del operador es algo que específicamente se dejó fuera del lenguaje deliberadamente. Ellos "hicieron trampa" un poco con la concatenación de cadenas, pero más allá de eso, tal funcionalidad no existe.

(descargo de responsabilidad: no he trabajado con los últimos 2 lanzamientos principales de java, así que si está ahora, estaré muy sorprendido)

Answer 10

Estoy usando la clase muy popular "org.apache.commons.lang.BooleanUtils"

Este método es probado por muchos usuarios y seguro. Que te diviertas. Uso:

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

Answer 11

Java tiene un operador lógico XOR , es ^ (como en a ^ b ).

Aparte de eso, no puedes definir nuevos operadores en Java.

Edición: Aquí hay un ejemplo:

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

Salida:

false ^ false = false false ^ true = true true ^ false = true true ^ true = false

Answer 12

Lógica exclusiva -o en Java se llama != . También puedes usar ^ si quieres confundir a tus amigos.

Answer 13

Lo que estás pidiendo no tendría mucho sentido. A menos que sea incorrecto, está sugiriendo que desea usar XOR para realizar operaciones lógicas de la misma manera que AND y OR. Su código provisto en realidad muestra a lo que me refiero:

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

Su función tiene entradas booleanas, y cuando se utiliza XOR bitwise en booleans, el resultado es el mismo que el código que ha proporcionado. En otras palabras, XOR a nivel de bits ya es eficiente al comparar bits individuales (booleanos) o al comparar los bits individuales en valores más grandes. Para poner esto en contexto, en términos de valores binarios, cualquier valor distinto de cero es VERDADERO y solo CERO es falso.

Por lo tanto, para que XOR se aplique de la misma manera en que se aplica el AND lógico, solo usará valores binarios con un solo bit (dando el mismo resultado y eficiencia) o el valor binario deberá evaluarse como un todo en lugar de por bit. En otras palabras, la expresión (010 ^^ 110) = FALSO en lugar de (010 ^^ 110) = 100. Esto eliminaría la mayor parte del significado semántico de la operación, y representa una prueba lógica que no debería usar de todos modos.

Answer 14

Puede utilizar Xtend (operadores Infix y sobrecarga de operadores) para sobrecargar operadores y ''permanecer'' en Java

Answer 15

Solo puedes escribir (a!=b)

Esto funcionaría igual que a ^ b .

Answer 16

Tal vez usted malinterpretó la diferencia entre & && , | y || El propósito de los operadores de acceso directo && y || es que el valor del primer operando puede determinar el resultado y, por lo tanto, el segundo operando no necesita ser evaluado.

Esto es especialmente útil si el segundo operando produce un error. p.ej

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

Sin embargo, con XOR , siempre debe evaluar el segundo operando para obtener el resultado, de modo que la única operación significativa sea ^ .

Answer 17

Tendrá que cambiar a Scala para implementar sus propios operadores.

ejemplo de tubería