Operador de acceso directo "or-assignment" (| =) en Java

Question

Tengo un largo conjunto de comparaciones que hacer en Java, y me gustaría saber si una o más de ellas aparecen como verdaderas. La secuencia de comparaciones fue larga y difícil de leer, así que la descompuse para poder leerla y automáticamente fui a usar un operador de acceso directo |= en lugar de negativeValue = negativeValue || boolean.

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

espero negativeValue para ser verdad si alguna de las predeterminado <algo> valores son negativos. Es esto valido? ¿Hará lo que espero? No pude verlo mencionado en el sitio de Sun o stackoverflow, pero Eclipse no parece tener un problema y el código se compila y ejecuta.

---

Del mismo modo, si quería realizar varias intersecciones lógicas, podría utilizar en lugar de &=&&?

Answer 1

El |= es un operador de asignación compuesto (JLS 15.26.2) para el operador lógico booleano | (JLS 15.22.2); no debe confundirse con el condicional o || (JLS 15.24). También hay &= y ^= correspondientes a la versión de asignación compuesta del booleano lógico & y ^, respectivamente.

En otras palabras, para boolean b1, b2, estos dos son equivalentes:

b1 |= b2; 
b1 = b1 | b2; 

La diferencia entre los operadores lógicos (& y |) en comparación con sus homólogos condicionales (&& y ||) es que el primero no lo hacen "cortocircuito"; este último lo hace. Es decir:

• & y | siempre evalúan ambos operandos
• && y || evaluar el operando derecho condicionalmente; el operando correcto se evalúa solo si su valor podría afectar el resultado de la operación binaria.Eso significa que el operando de la derecha no se evalúa cuando:
  • El operando izquierdo de && evalúa a false
    • (porque no importa lo que el operando de la derecha se evalúa como, toda la expresión es false)
  • El operando de la izquierda de || evalúa a true
    • (porque no m atter lo que el operando de la derecha se evalúa como, toda la expresión es true)

Así que volviendo a su pregunta original, sí, esa construcción es válida, y mientras |= no es exactamente un acceso directo equivalente para = y ||, calcula lo que desea. Dado que el lado derecho del operador |= en su uso es una operación de comparación entera simple, el hecho de que | no se cortocircuite es insignificante.

Hay casos, cuando se desea un cortocircuito, o incluso se requiere, pero el escenario no es uno de ellos.

Desafortunadamente, a diferencia de otros lenguajes, Java no tiene &&= y ||=. Esto fue discutido en la pregunta Why doesn't Java have compound assignment versions of the conditional-and and conditional-or operators? (&&=, ||=).

Answer 2

No es un operador de "atajo" (o cortocircuito) en la forma en que || y & & (ya que no evaluarán el RHS si ya conocen el resultado basado en el LHS) pero hará lo que usted desee en términos de trabajando.

Como un ejemplo de la diferencia, este código va a estar bien si text es nulo:

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

mientras que esto no será:

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

(Obviamente se podría hacer para que "".equals(text) particular, caso - Estoy tratando de demostrar el principio.)

Answer 3

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

Answer 4

Puede tener solo una declaración. Expresado en varias líneas se lee casi exactamente igual que el código de ejemplo, sólo es menos imperativa:

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

Para las expresiones más simples, utilizando | puede ser más rápido que || porque aunque evita hacer una comparación que significa el uso de una rama implícita y eso puede ser mucho más caro.

Answer 5

Aunque puede ser demasiado para su problema, la biblioteca Guava tiene una buena sintaxis con Predicate sy realiza una evaluación de cortocircuito de 0/Predicate s.

Esencialmente, las comparaciones se convierten en objetos, se empaquetan en una colección y luego se repiten. Para o predicados, el primer hit verdadero regresa de la iteración, y viceversa para y.

Answer 6

|| lógico booleano O
| OR bit a bit

| = bit a bit OR inclusivo y asignación operador

La razón por | = no shortcircit es porque hace un OR no un OR lógico. Es decir:

 

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

Tutorial for java operators

Answer 7

Si se trata de legibilidad Tengo el concepto de separación de datos a prueba de la lógica de la prueba.Ejemplo de código:

// declare data 
DataType [] dataToTest = new DataType[] { 
    defaultStock, 
    defaultWholesale, 
    defaultRetail, 
    defaultDelivery 
} 

// define logic 
boolean checkIfAnyNegative(DataType [] data) { 
    boolean negativeValue = false; 
    int i = 0; 
    while (!negativeValue && i < data.length) { 
     negativeValue = data[i++] < 0; 
    } 
    return negativeValue; 
} 

El código parece más prolijo y autoexplicativo. Usted puede incluso crear una matriz en la llamada al método, como esto:

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

Es más fácil de leer que 'cadena de comparación', y también tiene la ventaja de rendimiento de cortocircuito (a costa de asignación de matriz y llamada al método).

Editar: legibilidad Aún más puede ser alcanzado simplemente usando varargs parámetros:

firma método sería:

boolean checkIfAnyNegative(DataType ... data) 

Y la llamada podría tener este aspecto:

checkIfAnyNegative(defaultStock, defaultWholesale, defaultRetail, defaultDelivery);