Collegamento "or-assignment" (| =) operatore in Java

Question

Ho una lunga serie di confronti da fare in Java, e mi piacerebbe sapere se uno o più di essi risultano veri. La stringa dei confronti era lunga e difficile da leggere, quindi l'ho riorganizzata per renderla leggibile, e sono andato automaticamente a utilizzare un operatore di scorciatoia |= anziché negativeValue = negativeValue || boolean.

boolean negativeValue = false; 
negativeValue |= (defaultStock < 0); 
negativeValue |= (defaultWholesale < 0); 
negativeValue |= (defaultRetail < 0); 
negativeValue |= (defaultDelivery < 0); 

mi aspetto negativeValue per essere vero se qualcuno di default <qualcosa> valori sono negativi. È valido? Farà quello che mi aspetto? Non riuscivo a vederlo menzionato sul sito o sullo stackoverflow di Sun, ma Eclipse non sembra avere un problema con esso e il codice viene compilato ed eseguito.

---

Allo stesso modo, se volevo eseguire diverse intersezioni logiche, potrei usare &= invece di &&?

Answer 1

|= è un operatore di assegnazione composto (JLS 15.26.2) per l'operatore logico booleano | (JLS 15.22.2); da non confondere con il condizionale o || (JLS 15.24). Ci sono anche &= e ^= corrispondenti alla versione di assegnazione composta della logica booleana & e ^ rispettivamente.

In altre parole, per boolean b1, b2, questi due sono equivalenti:

b1 |= b2; 
b1 = b1 | b2; 

La differenza fra gli operatori logici (& e |) rispetto alle loro controparti condizionali (&& e ||) è che la prima non lo fanno "corto circuito"; quest'ultimo fa. Cioè:

• & e |sempre valutare entrambi gli operandi
• && e || valutano il diritto operando condizionatamente; l'operando di destra viene valutato solo se il suo valore può influire sul risultato dell'operazione binaria.Ciò significa che l'operando di destra non viene valutato quando:
  • L'operando a sinistra di && viene valutato come false
    • (perché non importa quale sia l'operando di destra restituisce, l'intera espressione è false)
  • L'operando sinistro || viene valutato come true
    • (perché nessuno m Atter ciò che l'operando di destra restituisce, l'intera espressione è true)

Quindi, tornando alla tua domanda iniziale, sì, che costrutto è valida, e mentre |= non è esattamente un collegamento equivalente per = e ||, calcola ciò che si desidera. Poiché il lato destro dell'operatore |= nel tuo utilizzo è un'operazione di confronto tra numeri interi, il fatto che | non sia cortocircuitato è insignificante.

Ci sono casi in cui si desidera un cortocircuito o addirittura richiesto, ma lo scenario non è uno di questi.

È spiacevole che a differenza di alcuni altri linguaggi, Java non ha &&= e ||=. Questo è stato discusso nella domanda Why doesn't Java have compound assignment versions of the conditional-and and conditional-or operators? (&&=, ||=).

Answer 2

Non è un operatore "di scelta rapida" (o di cortocircuito) nel modo in cui || e & & sono (nel senso che non valuteranno l'RHS se già conoscono il risultato basato sull'LHS) ma farà quello che vuoi in termini di funzionante.

Come esempio della differenza, questo codice sarà bene se text è nullo:

boolean nullOrEmpty = text == null || text.equals("") 

che ciò non sarà:

boolean nullOrEmpty = false; 
nullOrEmpty |= text == null; 
nullOrEmpty |= text.equals(""); // Throws exception if text is null 

(Ovviamente si potrebbe fare "".equals(text) per quel particolare caso: sto solo cercando di dimostrare il principio)

Answer 3

List<Integer> params = Arrays.asList (defaultStock, defaultWholesale, 
             defaultRetail, defaultDelivery); 
int minParam = Collections.min (params); 
negativeValue = minParam < 0; 

Answer 4

Si potrebbe avere solo una dichiarazione. Espressa su più righe che legge quasi esattamente come il vostro codice di esempio, solo meno imperativo:

boolean negativeValue 
    = defaultStock < 0 
    | defaultWholesale < 0 
    | defaultRetail < 0 
    | defaultDelivery < 0; 

Per le espressioni più semplici, utilizzando | può essere più veloce di || perché, anche se si evita di fare un confronto significa utilizzare un ramo implicitamente e questo può essere molte volte più costoso.

Answer 5

Anche se potrebbe essere eccessivo per il tuo problema, la libreria Guava ha una bella sintassi con Predicate s e esegue la valutazione di cortocircuito di o/e Predicate s.

In sostanza, i confronti vengono trasformati in oggetti, inseriti in una raccolta e quindi ripetuti. Per o predicati, il primo hit vero ritorna dall'iterazione e viceversa per e.

Answer 6

|| logico booleano OR
| OR bit a bit

| = bit a bit OR inclusivo e assegnazione operatore

Il motivo per cui | = non shortcircit è perché fa un OR bit a bit non un OR logico. Vale a dire:

 

C |= 2 is same as C = C | 2 

Tutorial for java operators

Answer 7

Se si tratta di leggibilità ho il concetto di separazione testato i dati dalla logica di test.Esempio di codice:

Il codice appare più dettagliato e autoesplicativo. Si può anche creare un array in chiamata di metodo, in questo modo:

checkIfAnyNegative(new DataType[] { 
    defaultStock, 
    defaultWholesale, 
    defaultRetail, 
    defaultDelivery 
}); 

E 'più leggibile di 'stringa di confronto', e ha anche vantaggi prestazionali di corto circuito (a costo di allocazione matrice e chiamata di metodo).

Edit: Ancora più leggibilità può essere ottenuto semplicemente utilizzando varargs parametri:

firma metodo sarebbe:

boolean checkIfAnyNegative(DataType ... data) 

e la chiamata potrebbe assomigliare a questo:

checkIfAnyNegative(defaultStock, defaultWholesale, defaultRetail, defaultDelivery);