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

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

Como ejemplo de la diferencia, este código estará bien si text es null:

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

Mientras que esto no:

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

(Obviamente se podría hacer "".equals(text) para ese caso particular - solo estoy tratando de demostrar el principio.)

Solo podrías tener una declaración. Expresado en múltiples líneas se lee casi exactamente como su código de ejemplo, solo que menos imperativo:

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

Para expresiones más simples, usar | puede ser más rápido que || porque aunque evita hacer una comparación significa usar una rama implícitamente y eso puede ser muchas veces más caro.

Aunque podría ser excesivo para su problema, la biblioteca Guava tiene una sintaxis agradable con Predicates y hace una evaluación de cortocircuito de or/and Predicate s.

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

Si se trata de legibilidad, tengo el concepto de separación de datos probados de la lógica de 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 se ve más detallado y se explica por sí mismo. Incluso puede crear una matriz en la llamada al método, como esta:

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

Es más legible que 'comparison string', y también tiene la ventaja de rendimiento de cortocircuitar (a costa de la asignación de matrices y la llamada a métodos).

Editar: Incluso más legibilidad se puede lograr simplemente mediante el uso parámetros de varargs:

La firma del método sería:

boolean checkIfAnyNegative(DataType ... data)

Y la llamada podría verse así:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

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

/ / booleano lógico O
/ bitwise OR

/ = operador OR y asignación inclusivo a bit

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

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

Tutorial para operadores java

Es un post antiguo, pero con el fin de proporcionar una perspectiva diferente para los principiantes, me gustaría dar un ejemplo.

Creo que el caso de uso más común para un operador compuesto similar sería +=. Estoy seguro de que todos escribimos algo como esto:

int a = 10;   // a = 10
a += 5;   // a = 15

¿Cuál era el punto de esto? Era para evitar escribir la variable a dos veces en la misma línea. (¿Me estoy perdiendo algo superior aquí?)

Entonces, la siguiente línea hace exactamente lo mismo, evitando escribir la variable b1 dos veces en la misma línea.

b1 |= b2;