que - sentencia if en java ejemplos

La mejor forma de formatear múltiples ''o'' condiciones en una sentencia if(Java)

Question

Una pregunta simple, pero Google no ha ayudado mucho.

Tengo una declaración if con muchas condiciones (tengo que verificar 10 o 15 constantes para ver si hay alguna de ellas presente).

En lugar de escribir algo como:

if (x == 12 || x == 16 || x == 19 || ...)

¿Hay alguna forma de formatearlo como

if x is [12, 16, 19]?

Me pregunto si existe una forma más fácil de codificar esto, cualquier ayuda apreciada.

Editar : Las respuestas fueron muy útiles, pero algunas personas me pidieron que agregara más detalles, así que lo haré para saciar su curiosidad. Estaba haciendo una clase de validación de fecha que necesitaba para asegurarme de que los días no eran> 30 en los meses que tienen solo 30 días (de los cuales hay 4, creo) y estaba escribiendo una declaración if para verificar cosas como esta:

if (day > 30 && (month == 4 || month == 6 || month == 9 || month == 11))

Me preguntaba si existía una forma más rápida de codificar cosas así; muchas de las respuestas a continuación me han ayudado :).

Answer 1

¿Quieres cambiar a esto?

switch(x) {
    case 12:
    case 16:
    case 19: 
        //Do something
        break;
    default:
        //Do nothing or something else..
        break;
}

Answer 2

Con Java 8, puedes usar una secuencia primitiva:

if (IntStream.of(12, 16, 19).anyMatch(i -> i == x))

pero esto puede tener una ligera sobrecarga (o no), dependiendo del número de comparaciones.

Answer 3

No, no puedes hacer eso en Java. Sin embargo, puedes escribir un método de la siguiente manera:

boolean isContains(int i, int ... numbers) {
    // code to check if i is one of the numbers
    for (int n : numbers) {
        if (i == n) return true;
    }
    return false;
}

Answer 4

Puede buscar la presencia de una clave de mapa o ver si está en un conjunto.

Sin embargo, dependiendo de lo que realmente estés haciendo , es posible que estés tratando de resolver el problema incorrectamente :)

Answer 5

Si el conjunto de posibilidades es "compacto" (es decir, el valor más grande - el valor más pequeño es, digamos, menos de 200) puede considerar una tabla de búsqueda. Esto sería especialmente útil si tuviera una estructura como

if (x == 12 || x == 16 || x == 19 || ...)
else if (x==34 || x == 55 || ...)
else if (...)

Configure una matriz con valores que identifiquen la rama que se tomará (1, 2, 3 en el ejemplo anterior) y luego se convertirán sus pruebas

switch(dispatchTable[x])
{
    case 1:
        ...
        break;
    case 2:
        ...
        break;
    case 3:
        ...
        break;
}

Que esto sea apropiado o no depende de la semántica del problema.

Si una matriz no es apropiada, puede usar un Map<Integer,Integer> , o si solo desea probar la membresía para una sola declaración, un Set<Integer> haría. Sin embargo, eso es mucho poder de fuego para una declaración simple simple, por lo que, sin más contexto, es difícil guiarlo en la dirección correcta.

Answer 6

Utilice una colección de algún tipo; esto hará que el código sea más legible y ocultará todas esas constantes. Una manera simple sería con una lista:

// Declared with constants
private static List<Integer> myConstants = new ArrayList<Integer>(){{
    add(12);
    add(16);
    add(19);
}};

// Wherever you are checking for presence of the constant
if(myConstants.contains(x)){
    // ETC
}

Como señala Bohemian, la lista de constantes puede ser estática, por lo que es accesible en más de un lugar.

Para cualquier persona interesada, la lista en mi ejemplo usa la inicialización de doble llave . Desde que me encontré con esto recientemente, me pareció bueno escribir inicializaciones de listas rápidas y sucias.

Answer 7

Yo uso este tipo de patrón a menudo. Es muy compacto

// Define a constant in your class. Use a HashSet for performance
private static final Set<Integer> values = new HashSet<Integer>(Arrays.asList(12, 16, 19));

// In your method:
if (values.contains(x)) {
    ...
}

HashSet se usa un HashSet para proporcionar un buen rendimiento de búsqueda: incluso los conjuntos de hash muy grandes pueden ejecutar contains() extremadamente rápido.

Si el rendimiento no es importante, puede codificar la esencia de esto en una sola línea:

if (Arrays.asList(12, 16, 19).contains(x))

pero sepa que creará una nueva ArrayList cada vez que se ejecute.