Création D'un opérateur" logical exclusive ou " en Java
Observations:
Java a une logique et un opérateur.
Java a un opérateur ou logique.
Java a un opérateur logique non.
problème:
Java n'a pas d'opérateur XOR logique, selon sun . Je tiens à en définir un.
Définition De La Méthode:
en tant que méthode, il est simplement défini 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);
Usage De L'Opérateur:
je préférerais 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ù dois-je commencer?
17 réponses
Java a un opérateur XOR logique , 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);
}
}
}
sortie:
false ^ false = false false ^ true = true true ^ false = true true ^ true = false
Java a une logique et un opérateur.
Java a un opérateur ou logique.
faux.
Java
- deux logiques ET les opérateurs: normal ET est et et en court-circuit ET est & & et
- deux opérateurs logiques ou: normal ou is |et court-circuit OU is|/.
XOR existe seulement en tant que^, parce que l'évaluation en court-circuit n'est pas possible.
peut-être avez-vous mal compris la différence entre &
et &&
, |
et ||
Le but des opérateurs de raccourci &&
et ||
est que la valeur de la première opérande puisse déterminer le résultat et donc la seconde opérande n'a pas besoin d'être évaluée.
Ceci est particulièrement utile si le deuxième opérande serait une erreur. par exemple
if (set == null || set.isEmpty())
// or
if (list != null && list.size() > 0)
cependant avec XOR , vous devez toujours évaluer le second opérande pour obtenir le résultat le sens de l'opération est ^
.
vous pouvez simplement écrire (a!=b)
cela fonctionnerait de la même manière que a ^ b
.
c'est parce que la surcharge de l'opérateur est quelque chose qu'ils ont spécifiquement omis de la langue délibérément. Ils ont "triché" un peu avec la concaténation de chaîne, 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 maintenant, je vais être très surpris)
le seul opérateur à surcharger Java est + on Strings ( JLS 15.18.1 String Concatenation Operator + ).
la communauté est divisée en 3 depuis des années, 1/3 n'en veut pas, 1/3 en veut et 1/3 s'en fout.
vous pouvez utiliser unicode pour créer des noms de méthodes 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 c'est va être douteux de certains éditeurs et limite puisque 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;
}
?
aussi, comme javashlook dit , il y a déjà ^
opérateur.
!=
et ^
fonctionnent de façon identique* pour les opérandes booléennes (votre cas), mais différemment pour les opérandes entières.
* Notes:
1. Ils fonctionnent de façon identique pour les opérandes boolean
(type primitif), mais pas pour les opérandes Boolean
(type d'objet). Comme Boolean
(type d'objet) les valeurs peuvent avoir la valeur null
. Et !=
retournera false
ou true
quand l'un de ses opérandes ou les deux sont null
, tandis que ^
lancera NullPointerException
dans ce cas.
2. Bien qu'ils fonctionnent de manière identique, ils ont une préséance différente, par exemple , lorsqu'il est utilisé avec &
: a & b != c & d
sera traité comme a & (b != c) & d
, tandis que a & b ^ c & d
sera traité comme (a & b) ^ (c & d)
(offtopic: ouch, C-style priorité table sucks).
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;
}
Profiter
vous pouvez utiliser Xtend (Infix Operators and Operator Overloading) pour surcharger les opérateurs et "rester" sur Java
ce que vous demandez n'aurait pas beaucoup de sens. Sauf erreur de ma part, vous suggérez que vous voulez utiliser XOR pour effectuer des opérations logiques de la même manière et / ou faire. Le code que vous m'avez fourni montre 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 quand bitwise XOR est utilisé sur booléens le résultat est le même que le code que vous avez fourni. En d'autres termes, bitwise XOR est déjà efficace lors de la comparaison les bits (booléens) ou en comparant les bits individuels dans des valeurs plus grandes. Pour mettre cela en contexte, en termes de valeurs binaires, toute valeur non nulle est vraie et seule la valeur Zéro est fausse.
donc, pour que XOR soit appliqué de la même manière logique et est appliqué, vous utiliseriez soit seulement des valeurs binaires avec juste un bit(donnant le même résultat et l'efficacité) ou la valeur binaire devrait être évaluée comme un tout 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 devraient être des valeurs booléennes pour faire != la même chose que xor de sorte que la table de vérité ressemblerait la même chose. Vous pouvez également utiliser !(A==B) lol.
je suis l'aide de la très populaire de la classe "org.Apache.commun.lang.BooleanUtils "
cette méthode est testée par de nombreux utilisateurs et sûre. Amuser. Usage:
boolean result =BooleanUtils.xor(new boolean[]{true,false});
exclusive logique-ou en Java est appelé !=
. Vous pouvez également utiliser ^
si vous voulez prendre vos amis.
parce que le type de données booléen est stocké comme un entier, les fonctions d'opérateur de bits comme une opération XOR si 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:
avec 2 valeurs int, retourner vrai si l'une est négative et l'autre positive. Sauf si le paramètre "négatif" est vrai, alors retourner 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 aurez besoin de passer à Scala pour mettre en œuvre vos propres opérateurs