Esiste un modo più semplice per verificare più valori rispetto a un valore in un'istruzione if?

Question

In sostanza, quello che voglio fare è controllare due interi contro un dato valore, dunque, classicamente quello che si potrebbe fare è qualcosa di simile:

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

Ma esiste un formato più conciso per fare questo? Forse simile a questo (che restituisce un tipo di operando cattivo):

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

Sfortunatamente non esiste un tale costrutto in Java.

E 'questo tipo di confronto è frequente nel codice, è possibile implementare una piccola funzione che eseguirà la verifica per voi:

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

allora si potrebbe utilizzare in questo modo:

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

Se non si desidera limitare yourselft a numeri interi, è possibile effettuare la funzione di cui sopra generica:

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

Nota che in questo caso il runtime Java eseguirà il boxing automatico e l'unboxing per i tipi primitivi (come int), che è una perdita di prestazioni.

Answer 2

penso che un bit per bit OR:

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

potrebbe funzionare se si desidera controllare specificamente per 0. I' Non sono sicuro se questo consente di risparmiare tempo di esecuzione. Più precisamente, rende il codice criptico, che renderà maledetto il futuro manutentore di questo codice (anche se stesso). Consiglio di attenersi all'opzione più tipografica.

Bah. Ho interpretato male la logica originale di OP.

un altro andare ...

Se si vuole verificare se una qualsiasi delle molte variabili è pari ad un valore atteso, una funzione generica potrebbe funzionare:

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

Questo lavoro per qualsiasi numero di oggetti di un tipo I primitivi saranno chiusi automaticamente in modo che funzionino anche con loro. Il tuo codice originale sarà qualcosa di simile:

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

(A nome del metodo migliore sarebbe un disperato bisogno di prendere in considerazione anche se questo un miglioramento rispetto a quello che hai ora Anche se il test si espande fino a 3 o 4 variabili, mi chiedo. . la necessità di questo tipo di cosa) si noti che questo funziona anche con le matrici:

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

e può essere utilizzato per verificare se una matrice (o qualsiasi di una collezione di variabili) è null.

Answer 3

Non esiste una sintassi speciale per questo. Potresti fare una funzione per quello. Supponendo almeno 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 
} 

Perché non tenerlo leggibile? Che cos'è lo non conciso a riguardo? D'altra parte,

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

comporta un cast non necessario. Perché non usare semplicemente Random e invocare nextInt()?

Answer 5

Anche se si è usato l'operazione a bit come suggerito Ted, le espressioni non sono uguali, in quanto si richiede almeno uno delle variabili a zero e il secondo richiede sia di loro di essere pari a zero .

Per quanto riguarda la domanda, non esiste tale scorciatoia in Java.

Answer 6

Per questo esempio, si può fare

if (a * b == 0) 

o per più variabili

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

mentre più concisa potrebbe non essere il più chiaro. Per valori superiori, è necessario eseguire il cast su long per evitare un overflow.

Answer 7

È possibile inserire gli interi in un set e vedere se contiene il valore specificato. Using Guava:

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

Ma due semplici paragoni int sono probabilmente più facile da capire in questo caso.

Answer 8

Si può provare questo codice:

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 

Quindi, se è possibile controllare in questo modo:

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

Answer 9

Ecco una modifica della risposta @ di Buc che può assumere qualsiasi numero di argomenti:

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

Answer 10

È possibile effettuare quanto segue in plain java

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

Answer 11

As referenced from this answer:

In Java 8 +, è possibile utilizzare un Stream e anyMatch. Qualcosa di simile

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

Nota che questo ha la possibilità di correre più lento rispetto agli altri se i controlli, a causa del sovraccarico di avvolgere questi elementi in un torrente per cominciare.