Operador de atalho “ou atribuição” (| =) em Java

Tenho um longo conjunto de comparações para fazer em Java e gostaria de saber se uma ou mais delas são verdadeiras. A sequência de comparações era longa e difícil de ler, então eu a separei para facilitar a leitura e automaticamente passei a usar um operador de atalho em |=vez de negativeValue = negativeValue || boolean.

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

Espero negativeValueque seja verdade se algum dos valores padrão de <algo> for negativo. Isso é válido? Vai fazer o que eu espero? Eu não pude ver isso mencionado no site da Sun ou stackoverflow, mas o Eclipse não parece ter problemas com isso e o código compila e executa.

Da mesma forma, se eu quisesse realizar várias interseções lógicas, poderia usar em &=vez de &&?

O |=é um operador de atribuição composto ( JLS 15.26.2 ) para o operador lógico booleano |( JLS 15.22.2 ); não deve ser confundido com o condicional ou ||( JLS 15.24 ). Existem também &=e ^=correspondentes à versão de atribuição composta da lógica booleana &e ^respectivamente.

Em outras palavras, para boolean b1, b2, esses dois são equivalentes:

 b1 |= b2;
 b1 = b1 | b2;

A diferença entre os operadores lógicos (& e |) em comparação com suas contrapartes condicionais ( &&e ||) é que os primeiros não "curto-circuito"; o último faz. Isso é:

• &e | sempre avaliar ambos os operandos
• &&e ||avaliar o operando certo condicionalmente ; o operando certo é avaliado apenas se seu valor puder afetar o resultado da operação binária. Isso significa que o operando certo NÃO é avaliado quando:
  • O operando esquerdo de && avalia parafalse
    • (porque não importa qual seja a avaliação do operando correto, a expressão inteira é false)
  • O operando esquerdo de || avalia paratrue
    • (porque não importa qual seja a avaliação do operando correto, a expressão inteira é true)

Então, voltando à sua pergunta original, sim, essa construção é válida, e while |=não é exatamente um atalho equivalente para =e|| , ele calcula o que você deseja. Como o lado direito do |=operador em seu uso é uma operação simples de comparação de inteiros, o fato de |não causar curto-circuito é insignificante.

Há casos em que o curto-circuito é desejado, ou mesmo obrigatório, mas o seu cenário não é um deles.

É uma pena que, ao contrário de outras linguagens, Java não tenha &&=e ||=. Isso foi discutido na pergunta Por que o Java não tem versões de atribuição composta dos operadores condicional e e condicional ou? (&& =, || =) .

Não é um operador de "atalho" (ou curto-circuito) da maneira que || e && são (no sentido de que eles não avaliarão o RHS se já souberem o resultado baseado no LHS), mas fará o que você quiser em termos de trabalho .

Como um exemplo da diferença, este código ficará bem se textfor nulo:

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

enquanto isso não:

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

(Obviamente, você poderia servir "".equals(text)nesse caso específico - estou apenas tentando demonstrar o princípio.)

Você poderia ter apenas uma declaração. Expresso em várias linhas, ele é lido quase exatamente como seu código de amostra, mas menos imperativo:

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

Para expressões mais simples, usar |pode ser mais rápido do que ||porque, embora evite fazer uma comparação, significa usar uma ramificação implicitamente e isso pode ser muito mais caro.

Embora possa ser um exagero para o seu problema, a biblioteca Guava tem uma boa sintaxe com se Predicatefaz avaliação de curto-circuito de or / e Predicates.

Essencialmente, as comparações são transformadas em objetos, empacotadas em uma coleção e, em seguida, iteradas. Para ou predicados, o primeiro hit verdadeiro retorna da iteração e vice-versa para e.

Se for sobre legibilidade, tenho o conceito de separação de dados testados da lógica de teste. Amostra 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;
}

O código parece mais detalhado e autoexplicativo. Você pode até criar uma matriz na chamada de método, assim:

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

É mais legível do que 'string de comparação' e também tem a vantagem de desempenho de curto-circuito (ao custo de alocação de array e chamada de método).

Editar: ainda mais legibilidade pode ser alcançada simplesmente usando parâmetros varargs:

A assinatura do método seria:

boolean checkIfAnyNegative(DataType ... data)

E a chamada pode ser assim:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

É um post antigo, mas para dar uma perspectiva diferente para iniciantes, gostaria de dar um exemplo.

Acho que o caso de uso mais comum para um operador composto semelhante seria +=. Tenho certeza de que todos nós escrevemos algo assim:

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

Qual foi o objetivo disto? O objetivo era evitar boilerplate e eliminar o código repetitivo.

Assim, a próxima linha faz exatamente o mesmo, evitando digitar a variável b1duas vezes na mesma linha.

b1 |= b2;

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

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

| = bit a bit OR inclusivo e operador de atribuição

A razão pela qual | = não curto-circuito é porque ele faz um OR bit a bit e não um OR lógico. Quer dizer:

C | = 2 é igual a C = C | 2

Tutorial para operadores java