¿Hay alguna manera más simple de verificar valores múltiples contra un valor en un enunciado if?

Question

Básicamente, lo que quiero hacer es comprobar dos enteros frente a un valor determinado, por lo tanto, clásicamente lo que se puede hacer es algo como esto:

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

Pero, ¿existe un formato más concisa para hacer esto? Posiblemente similar a esta (que devuelve un mal tipo de operando):

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

Answer 1

Desafortunadamente, no existe tal construcción en Java.

Es este tipo de comparación es frecuente en su código, se puede aplicar una pequeña función que va a realizar la comprobación para usted:

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

entonces se podría utilizar de esta manera:

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

Si no desea restringir yourselft a números enteros, puede hacer que la función anterior genérica:

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

Tenga en cuenta que en este caso el tiempo de ejecución de Java realizará boxeo automático y unboxing para tipos primitivos (como int), que es una pérdida de rendimiento.

Answer 2

Creo que un bit a bit OR:

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

funcionaría si desea comprobar específicamente para 0. I' m no estoy seguro si esto ahorra tiempo de ejecución. Más al punto, crea un código críptico, que hará que el futuro mantenedor de este código te maldiga (incluso si eres tú mismo). Recomiendo seguir con la opción de escribir más.

Bah. Leí mal la lógica original de OP.

otro aire ...

Si desea probar si cualquiera de muchas variables es igual a un valor esperado, una función genérica podría funcionar:

public <T> 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; 
} 

Esto funcionará para cualquier cantidad de objetos de un tipo. Primitivas se autoboxan por lo que funcionará con ellos también. Su código original será algo como:

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

(se necesita desesperadamente un nombre mejor método para siquiera considerar si esto una mejora con respecto a lo que tenemos ahora Incluso si la prueba se expande a 3 o 4 variables, pongo en duda. . la necesidad de este tipo de cosas) Tenga en cuenta que esto también funciona con matrices:

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

y que puede ser utilizado para probar si una matriz (o cualquiera de un conjunto de variables) es null.

Answer 3

No hay una sintaxis especial para eso. Podrías hacer una función para eso. Asumiendo al menos Java 1.5:

public <T> boolean eitherOneEquals(T o1, T o2, T expectedValue) { 
    return o1.equals(expectedValue) || o2.equals(expectedValue); 
} 

if(eitherOneEquals(o1, o2, expectedValue)) { 
    // do something... 
} 

Answer 4

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

¿Por qué no mantenerlo legible? ¿Cuál es no conciso sobre esto? Por otro lado,

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

implica un lanzamiento innecesario. ¿Por qué no usar Random e invocar nextInt()?

Answer 5

Incluso si usted ha usado la operación bit a bit como se sugiere Ted, las expresiones no son iguales, ya que se requiere al menos uno de las variables a ser cero y la segunda requiere tanto de ellos a ser cero .

En cuanto a su pregunta, no existe tal atajo en Java.

Answer 6

Para este ejemplo, se puede hacer

if (a * b == 0) 

o para las variables más

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

mientras que más concisa que puede no ser tan clara. Para valores más grandes, debe convertir a long para evitar un desbordamiento.

Answer 7

Puede poner los enteros en un conjunto y ver si contiene el valor dado. Using Guava:

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

Sin embargo, dos simples comparaciones int son probablemente más fácil de entender en este caso.

Answer 8

Puede probar este código:

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 

lo tanto, si se puede comprobar de esta manera:

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

Answer 9

Aquí es una modificación de la respuesta de @ Buc que puede tomar cualquier número de argumentos:

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

Answer 10

Puede hacer lo siguiente en simple java

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

Answer 11

As referenced from this answer:

En Java 8+, podría utilizar un Stream y anyMatch. Algo así como

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

Tenga en cuenta que esto no tiene la oportunidad de correr más lento que el otro si los controles, debido a la sobrecarga de envolver estos elementos en una corriente, para empezar.