Création d'un opérateur "logique exclusif ou" en Java
Observations:
Java a un opérateur logique AND.
Java a un opérateur logique OR.
Java a un opérateur logique NOT.
Problème:
Java n'a pas d'opérateur logique XOR, selon Sun . J'aimerais 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 s'appelle de la manière suivante:
boolean myVal = logicalXOR(x, y);
Utilisation de l'opérateur:
Je préférerais de beaucoup avoir 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. Où devrais-je commencer?
Java a un opérateur logique XOR, il s'agit de ^ (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);
}
}
}
Sortie:
false ^ false = false false ^ true = true true ^ false = true true ^ true = false
N'est-ce pas x! = Y?
Java a un opérateur logique AND.
Java a un opérateur logique OR.
Faux.
Java a
- deux opérateurs AND logiques: AND normal et & est le court-circuit AND est &&, et
- deux opérateurs logiques OR: normal OR est | et le court-circuit OR est ||.
XOR n'existe qu'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 rôle des opérateurs de raccourci && et || est que la valeur du premier opérande puisse déterminer le résultat et qu'il n'est donc pas nécessaire d'évaluer le second opérande.
Ceci est particulièrement utile si le deuxième opérande entraîne une erreur .
if (set == null || set.isEmpty())
// or
if (list != null && list.size() > 0)
Cependant, avecXOR, vous devez toujours évaluer le second opérande pour obtenir le résultat. La seule opération significative est donc ^.
Vous pouvez simplement écrire (a!=b)
Cela fonctionnerait de la même manière que a ^ b.
En effet, la surcharge des opérateurs est quelque chose qu'ils ont expressément exclu du langage. Ils ont "triché" un peu avec la concaténation de chaînes, mais au-delà, une telle fonctionnalité n'existe pas.
(disclaimer: je n'ai pas travaillé avec les 2 dernières versions majeures de Java, donc si c'est maintenant, je serai très surpris)
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;
}
?
En outre, comme javashlook dit , il y a déjà l'opérateur ^.
!= et ^ fonctionnent de manière identique * pour les opérandes booléens (votre cas), mais différemment pour les opérandes entiers.
* Remarques:
1. Ils fonctionnent de manière identique pour boolean (type primitif), mais pas les opérandes Boolean (type d'objet). Comme Boolean (type d'objet), les valeurs peuvent avoir la valeur null. Et != renverra false ou true lorsque l'un de ses opérandes ou les deux sont null, alors que ^ lancera NullPointerException dans ce cas.
2. Bien qu'ils fonctionnent de manière identique, ils ont une priorité différente, par exemple. lorsqu'il est utilisé avec &: a & b != c & d sera traité comme a & (b != c) & d, alors que a & b ^ c & d sera traité comme (a & b) ^ (c & d) (offtopic: ouch, la table de priorité de style C est nulle).
Le seul opérateur surchargé en Java est + on Strings ( JLS 15.18.1 Opérateur de concaténation de chaînes + ).
La communauté est divisée en trois années, 1/3 n'en veut pas, 1/3 en veut et 1/3 s'en moque.
Vous pouvez utiliser unicode pour créer des noms de méthodes sous forme de symboles ... Ainsi, si vous souhaitez utiliser un symbole, vous pouvez utiliser myVal = x. $ (Y); où $ est le symbole et x n'est pas une primitive ... mais dans certains éditeurs, cela va être louche et est limité car vous ne pouvez pas le faire sur une primitive.
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
Vous pouvez utiliser Xtend (opérateurs d'infixes et surcharge d'opérateurs) pour surcharger les opérateurs et "rester" sous Java
Ce que vous demandez n'a pas beaucoup de sens. À moins que je ne me trompe, vous proposez d'utiliser XOR pour effectuer les opérations logiques de la même manière ET et OR do. Le code fourni montre en fait ce que je veux dire:
public static boolean logicalXOR(boolean x, boolean y) {
return ( ( x || y ) && ! ( x && y ) );
}
Votre fonction a des entrées booléennes et lorsque bitwise XOR est utilisé sur les booléens, le résultat est identique au code que vous avez fourni. En d'autres termes, bitwise XOR est déjà efficace pour comparer des bits individuels (booléens) ou comparer des bits individuels dans des valeurs plus grandes. Pour mettre cela dans son contexte, en termes de valeurs binaires, toute valeur autre que zéro est VRAIE et que ZERO est faux.
Donc, pour que XOR soit appliqué de la même manière que AND logique, 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 devait être évaluée entier au lieu de par bit. En d'autres termes, l'expression (010 ^^ 110) = FALSE au lieu de (010 ^^ 110) = 100. Cela supprimerait la majeure partie de la signification sémantique de l'opération et représenterait un test logique que vous ne devriez pas utiliser de toute façon.
Logical exclusive-or en Java s'appelle !=. Vous pouvez également utiliser ^ si vous voulez confondre vos amis.
J'utilise la classe très populaire "org.Apache.commons.lang.BooleanUtils"
Cette méthode est testée par de nombreux utilisateurs et en toute sécurité. Amusez-vous .
boolean result =BooleanUtils.xor(new boolean[]{true,false});
A et B doivent être des valeurs booléennes pour faire! = Identiques à xor pour que la table de vérité ait le même aspect. Vous pouvez également utiliser! (A == B) lol.
Voici un exemple:
Avec 2 valeurs int, retourne vrai si l'une est négative et l'autre positive. Sauf si le paramètre "négatif" est vrai, alors ne renvoie 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);
}
Le type de données booléen étant 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
*/
}
}
vous devrez passer à Scala pour implémenter vos propres opérateurs