La création d'une “logique ou exclusif” opérateur en Java

Java a une logique opérateur XOR, il est ^ (comme dans a ^ b).

En dehors de cela, vous ne pouvez pas définir de nouveaux opérateurs en Java.

Edit: Voici un exemple:

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

De sortie:

faux ^ faux = faux 
faux ^ vrai = vrai 
vrai ^ faux = vrai 
vrai ^ vrai = faux 

Java a une logique ET de l'opérateur.

Java est un opérateur logique OU.

Mal.

Java a

• deux logiques ET les opérateurs: normal ET est & et de court-circuit ET est &&, et
• deux les opérateurs logiques OU: normal OU est | et en court-circuit OU est ||.

XOR n'existe qu' ^, parce évaluation de court-circuit n'est pas possible.

Vous pouvez simplement écrire (a!=b)

Cela fonctionne de la même façon que a ^ b.

La seule surcharge d'opérateur en Java est de + sur les Chaînes (JLS 15.18.1 Opérateur de Concaténation de Chaîne +).

La communauté a été divisée par 3 depuis des années, 1/3 n'en veut pas, 1/3 voulez, et 1/3 n'a pas de soins.

Vous pouvez utiliser l'unicode pour créer des noms de méthode qui sont des symboles... donc si vous avez un symbole que vous souhaitez utiliser, vous pourriez faire myVal = x.$(y); où $ est le symbole et x n'est pas une primitive... mais qui va être douteux de certains éditeurs et limite puisque vous ne pouvez pas le faire sur une primitive.

Ici est une var arg XOR méthode pour java...

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

Profiter de

Ce que vous me demandez ne serait pas beaucoup de sens. Sauf si je suis incorrect, vous êtes ce qui suggère que vous souhaitez utiliser XOR pour effectuer des opérations Logiques de la même manière ET et OU de faire. Votre code fourni montre réellement ce que je suis en faisant référence à:

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

Votre fonction booléenne entrées, et quand XOR au niveau du bit est utilisé sur les booléens le résultat est le même que le code que vous avez fournis. En d'autres termes, XOR au niveau du bit est déjà efficace lorsque l'on compare les bits individuels(booléens) ou comparer les bits individuels dans de plus grandes valeurs. Pour mettre cela en contexte, en termes de valeurs binaires toute valeur non nulle est VRAIE et seulement le ZÉRO est faux.

Donc pour XOR être appliquée de la même façon Logique ET est appliquée, vous devrez soit utiliser uniquement des valeurs binaires avec juste un peu(ce qui donne le même résultat et de l'efficacité) ou la valeur binaire devra être évaluée dans son ensemble au lieu de par bit. En d'autres termes, l'expression ( 010 ^^ 110 ) = FALSE au lieu de ( 010 ^^ 110 ) = 100. Ce serait d'enlever la plupart de la sémantique de l'opération, et représente un test logique, vous ne devriez pas l'utiliser de toute façon.

A et B doivent être des valeurs booléennes à faire != le même que le xor de sorte que la table de vérité serait le même aspect. Vous pouvez également utiliser !(A==B) lol.

Parce que type de données booléen est stocké comme un entier, bits opérateur ^ fonctionne comme une opération XOR avec des valeurs booléennes.

//©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
            */
        }
    }

vous aurez besoin de passer à la Scala de mettre en œuvre votre propre des opérateurs

pipe exemple