Оператор быстрого доступа "or-assignment" ( | = ) в Java

это не" ярлык " (или короткое замыкание) оператор таким образом, что | / и && являются (в том, что они не будут оценивать RHS, если они уже знают результат на основе LHS), но он будет делать то, что вы хотите с точки зрения работающего.

в качестве примера разницы, этот код будет хорошо, если text имеет значение null:

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

в то время как это не будет:

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

(очевидно, что вы могли бы сделать "".equals(text) для этого конкретного случая - я просто пытаюсь продемонстрировать принцип.)

у вас может быть только одно заявление. Выраженный в нескольких строках он читает почти точно так же, как ваш пример кода, только менее императивно:

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

для простейших выражений, используя | может быть быстрее, чем || потому что даже если он избегает делать сравнение, это означает неявное использование ветви, и это может быть во много раз дороже.

хотя это может быть излишним для вашей проблемы,гуавы библиотека имеет хороший синтаксис с Predicates и делает оценку короткого замыкания или / и Predicate s.

по существу, сравнения превращаются в объекты, упаковываются в коллекцию, а затем повторяются. Для предикатов or первое истинное попадание возвращается из итерации, и наоборот для and.

если речь идет о читаемости, у меня есть концепция разделения проверенных данных из логики тестирования. Пример кода:

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

код выглядит более подробным и понятным. Вы даже можете создать массив в вызове метода, например:

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

Он более читаем, чем "строка сравнения", а также имеет преимущество в производительности короткого замыкания (за счет выделения массива и вызова метода).

Edit: Даже больше удобочитаемости может быть просто достигнуто с помощью параметров varargs:

подпись метода будет:

boolean checkIfAnyNegative(DataType ... data)

и вызов может выглядеть так:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

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

|| логическое логическое или
/ побитовое или

|= побитовое включение или и оператор присваивания

причина, по которой |= не shortcircit, заключается в том, что он делает побитовое или не логическое или. То есть:

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

учебник для операторов java

Это старый пост, но для того, чтобы обеспечить другую перспективу для начинающих, я хотел бы привести пример.

Я думаю, что наиболее распространенным вариантом использования для аналогичного составного оператора будет +=. Я уверен, что мы все написали что-то вроде этого:

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

какой в этом был смысл? Это было, чтобы избежать записи переменной a дважды в одной строке. (Я упускаю что-то предлагает?)

Итак, следующая строка делает то же самое, избегая введите переменную b1 дважды в одной строке.

b1 |= b2;