Existe-t-il un moyen plus simple de comparer plusieurs valeurs par rapport à une valeur dans une instruction if?

En gros, ce que je veux faire, c’est comparer deux entiers à une valeur donnée. Par conséquent, classiquement, ce que vous feriez ressemblerait à ceci:

//just to get some values to check int a, b; a = (int)(Math.random()*5); b = (int)(Math.random()*5); //the actual thing in question if(a == 0 || b == 0) { //Then do something } 

Mais existe-t-il un format plus concis pour ce faire? Peut-être similaire à ceci (qui renvoie un type d’opérande incorrect):

 //just to get some values to check int a, b; a = (int)(Math.random()*5); b = (int)(Math.random()*5); //the actual thing in question if((a||b) == 0) { //Then do something } 

Malheureusement, il n’existe pas de telle construction en Java.

Si ce type de comparaison est fréquent dans votre code, vous pouvez implémenter une petite fonction qui effectuera la vérification pour vous:

 public boolean oneOfEquals(int a, int b, int expected) { return (a == expected) || (b == expected); } 

Ensuite, vous pourriez l’utiliser comme ceci:

 if(oneOfEquals(a, b, 0)) { // ... } 

Si vous ne voulez pas vous limiter à des entiers, vous pouvez rendre la fonction ci-dessus générique:

 public  boolean oneOfEquals(T a, T b, T expected) { return a.equals(expected) || b.equals(expected); } 

Notez que dans ce cas, Java Runtime exécutera une boxe et un unboxing automatiques pour les types primitifs (comme int ), ce qui constitue une perte de performance.

Vous pouvez faire ce qui suit en java

 Arrays.asList(a, b, c, d).contains(x); 

Je pense qu’un bit-wise OU:

 if ((a | b) == 0) . . . 

fonctionnerait si vous voulez vérifier spécifiquement pour 0. Je ne sais pas si cela économise du temps d’exécution. Plus précisément, cela rend le code cryptique, ce qui fera que le futur responsable de ce code vous maudira (même si c’est vous-même). Je recommande de restr avec l’option plus typée.

Bah. J’ai mal interprété la logique d’origine de l’OP.

Un autre aller …

Si vous souhaitez tester si l’une des nombreuses variables est égale à une valeur attendue, une fonction générique peut fonctionner:

 public  boolean exists(T target, T... values) { for (T value : values) { if (target == null) { if (value == null) { return true; } } else if (target.equals(value)) { return true; } } return false; } 

Cela fonctionnera pour n’importe quel nombre d’objects d’un type. Les primitives seront automatiquement classées, ce qui fonctionnera également avec elles. Votre code d’origine sera quelque chose comme:

 if (test(0, a, b)) { // do something } 

(Un meilleur nom de méthode serait absolument nécessaire pour déterminer si cela constitue une amélioration par rapport à ce que vous avez actuellement. Même si le test se développe en 3 ou 4 variables, je doute de la nécessité de ce genre de chose.) tableaux:

 int[] values = { . . . }; if (test(0, values)) { . . . 

et il peut être utilisé pour tester si un tableau (ou une collection de variables) est null .

 if(a == 0 || b == 0) { //Then do something } 

Pourquoi ne pas le garder lisible? Qu’est-ce qui n’est pas concis à ce sujet? D’autre part,

 a = (int)(Math.random()*5); 

implique une dissortingbution inutile. Pourquoi ne pas simplement utiliser Random et invoquer nextInt() ?

Pour cet exemple, vous pouvez faire

 if (a * b == 0) 

ou pour plus de variables

 if (a * b * c * d == 0) 

Bien que plus concis, il peut ne pas être aussi clair. Pour des valeurs plus grandes, vous devez utiliser une conversion long pour éviter un débordement.

Vous pouvez mettre les entiers dans un ensemble et voir s’il contient la valeur donnée. Utilisation de goyave :

 if(newHashSet(a, b).contains(0)){ // do something } 

Mais deux comparaisons simples sont probablement plus faciles à comprendre dans ce cas.

Voici une modification de la réponse de @buc ​​qui peut prendre n’importe quel nombre d’arguments:

 public  boolean oneOfEquals(T expected, T... os) { for (T o : os) { if (expected.equals(o)) return true; } return false; } 

Même si vous avez utilisé l’opération binary comme suggéré par Ted, les expressions ne sont pas égales, car l’une requirejs au moins l’ une des variables pour être zéro et la seconde exige que les deux soient nulles.

Concernant votre question, il n’y a pas de raccourci en Java.

Vous pouvez essayer ce code:

 public static boolean match (Object ref, Object... objects) { if (ref == null) return false; // for (Object obj : objects) if (obj.equals (ref)) return true; // return false; } // match 

Donc, si vous pouvez vérifier de cette façon:

 if (match (reference, "123", "124", "125")) ; // do something 

Comme indiqué dans cette réponse :

Dans Java 8+, vous pouvez utiliser un Stream et anyMatch . Quelque chose comme

 if (Stream.of(b, c, d).anyMatch(x -> x.equals(a))) { // ... do something ... } 

Notez que cela risque de s’exécuter plus lentement que les autres si vous effectuez des vérifications, en raison de la surcharge liée à la mise en place de ces éléments dans un stream.

Il n’y a pas de syntaxe spéciale pour cela. Vous pourriez faire une fonction pour ça. En supposant au moins Java 1.5:

 public  boolean eitherOneEquals(T o1, T o2, T expectedValue) { return o1.equals(expectedValue) || o2.equals(expectedValue); } if(eitherOneEquals(o1, o2, expectedValue)) { // do something... }