Création d'un opérateur «logique exclusif ou» en Java

Observations:

Java a un opérateur ET logique.
Java a un opérateur OU logique.
Java a un opérateur NOT logique.

Problème:

Selon Sun , Java n'a pas d'opérateur XOR logique . Je voudrais en définir un.

Définition de la méthode:

En tant que méthode, elle est simplement définie comme suit:

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

Appel de méthode:

Cette méthode est appelée de la manière suivante:

boolean myVal = logicalXOR(x, y);

Utilisation de l'opérateur:

Je préférerais de loin un opérateur, utilisé comme suit:

boolean myVal = x ^^ y;

Question:

Je ne trouve rien sur la façon de définir un nouvel opérateur en Java. Par où dois-je commencer?

Java a un opérateur XOR logique , c'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);
        }
    }
}

Production:

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

N'est-ce pas x! = Y?

Java a un opérateur ET logique.
Java a un opérateur OU logique.

Faux.

Java a

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

XOR existe uniquement en tant que ^, car l'évaluation des courts-circuits n'est pas possible.

Vous avez peut-être mal compris la différence entre &et &&, |et || Le but des opérateurs de raccourci &&et ||est que la valeur du premier opérande peut déterminer le résultat et donc le deuxième opérande n'a pas besoin d'être évalué.

Cela est particulièrement utile si le deuxième opérande entraîne une erreur. par exemple

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

Cependant, avec XOR , vous devez toujours évaluer le deuxième opérande pour obtenir le résultat, de sorte que la seule opération significative soit ^.

Vous pouvez simplement écrire (a!=b)

Cela fonctionnerait de la même manière que a ^ b.

C'est parce que la surcharge des opérateurs est quelque chose qu'ils ont spécifiquement laissé de côté délibérément. Ils ont "triché" un peu avec la concaténation de chaînes, mais au-delà, une telle fonctionnalité n'existe pas.

(Avertissement: je n'ai pas travaillé avec les 2 dernières versions majeures de Java, donc si c'est le cas maintenant, je serai très surpris)

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

La communauté est divisée en 3 depuis des années, 1/3 n'en veut pas, 1/3 le veulent et 1/3 s'en fiche.

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

Le code suivant:

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

est superflu.

Pourquoi ne pas écrire:

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

?

De plus, comme l'a dit javashlook , il y a déjà un ^opérateur.

!=et ^fonctionnent de manière identique * pour les opérandes booléens (votre cas), mais différemment pour les opérandes entiers.

<sub>* Notes:
1. Ils fonctionnent de manière identique pour les opérandes boolean(type primitif), mais pas Boolean(type objet). En tant que Boolean(type d'objet), les valeurs peuvent avoir une valeur null. Et !=retournera falseou truelorsque l'un ou les deux de ses opérandes le sont null, tandis que ^jettera NullPointerExceptiondans ce cas.
2. Bien qu'ils fonctionnent de manière identique, ils ont une priorité différente, par exemple lorsqu'ils sont utilisés avec &: a & b != c & dseront traités comme a & (b != c) & d, tandis que a & b ^ c & dseront traités comme (a & b) ^ (c & d)(hors sujet: aïe, le tableau de priorité de style C est nul).</sub>

Voici une méthode var arg XOR pour java ...

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

Prendre plaisir

Logique exclusif ou en Java est appelé !=. Vous pouvez également l'utiliser ^si vous souhaitez confondre vos amis.

Vous pouvez utiliser Xtend (Infix Operators et Operator Overloading) pour surcharger les opérateurs et «rester» sur Java

Ce que vous demandez n'aurait pas beaucoup de sens. À moins que je ne me trompe, vous suggérez que vous souhaitez utiliser XOR pour effectuer les opérations logiques de la même manière ET et OU. Votre code fourni montre en fait ce à quoi je me réfère:

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

Votre fonction a des entrées booléennes et lorsque XOR au niveau du bit est utilisé sur les booléens, le résultat est le même que le code que vous avez fourni. En d'autres termes, XOR au niveau du bit est déjà efficace lors de la comparaison de bits individuels (booléens) ou de la comparaison des bits individuels dans des valeurs plus grandes. Pour mettre cela en contexte, en termes de valeurs binaires, toute valeur non nulle est TRUE et seul ZERO est faux.

Donc, pour que XOR soit appliqué de la même manière que Logical AND est appliqué, vous n'utiliseriez que des valeurs binaires avec un seul bit (donnant le même résultat et la même efficacité) ou la valeur binaire devrait ê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. Cela supprimerait la plupart du sens sémantique de l'opération et représente un test logique que vous ne devriez pas utiliser de toute façon.

A et B doivent être des valeurs booléennes pour que! = Soit le même que xor afin que la table de vérité soit identique. Vous pouvez également utiliser! (A == B) lol.

J'utilise la classe très populaire "org.apache.commons.lang.BooleanUtils"

Cette méthode est testée par de nombreux utilisateurs et sûre. S'amuser. Usage:

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

Comme le type de données booléen est stocké comme un entier, l'opérateur de bit ^ fonctionne comme une opération XOR s'il est utilisé 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
            */
        }
    }

Voici un exemple:

Étant donné 2 valeurs int, renvoyez true si l'une est négative et l'autre positive. Sauf si le paramètre "négatif" est vrai, ne retournez vrai que si les deux sont négatifs.

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

vous devrez passer à Scala pour implémenter vos propres opérateurs

exemple de tuyau