Operator skrótu "or-assignment" (|=) w Javie

Nie jest operatorem" skrótu " (lub zwarcia) w taki sposób, że | / i & & są (w tym, że nie będą oceniać RHS, jeśli znają już wynik na podstawie LHS), ale zrobi to, co chcesz pod względem działa .

Jako przykład różnicy, ten kod będzie w porządku, jeśli text jest null:

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

Natomiast to nie będzie:

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

(Oczywiście możesz zrobić "".equals(text) w tym konkretnym przypadku-staram się tylko zademonstrować zasadę.)

Możesz mieć tylko jedno oświadczenie. Wyrażony w wielu wierszach czyta prawie dokładnie tak, jak Twój przykładowy kod, tylko mniej imperatywny:

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

Dla najprostszych wyrażeń, użycie | może być szybsze niż ||, ponieważ nawet jeśli unika się porównywania, oznacza użycie gałęzi w domyśle i to może być wielokrotnie droższe.

Chociaż może to być przesada dla Twojego problemu, biblioteka Guava ma jakąś ładną składnię z Predicate s i robi zwarcie oceny or / I Predicate s.

Zasadniczo porównania są przekształcane w obiekty, pakowane do kolekcji, a następnie powtarzane. Dla predykatów or, pierwszy prawdziwy hit powraca z iteracji i odwrotnie Dla and.

Jeśli chodzi o czytelność, mam pojęcie oddzielenia testowanych danych od logiki testowania. Przykład kodu:

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

Kod wygląda bardziej zwięzle i jasno. Można nawet utworzyć tablicę w wywołaniu metody, jak to:

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

Jest bardziej czytelny niż 'comparison string' , a także ma przewagę wydajności zwarcia (kosztem alokacji tablicy i wywołania metody).

Edit: Jeszcze większą czytelność można po prostu osiągnąć za pomocą parametry varargs:

Podpis metody będzie:

boolean checkIfAnyNegative(DataType ... data)

A wywołanie może wyglądać tak:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

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

|| logiczny boolean OR
/ bitowe lub

| = bitowy inkluzywny operator OR i przypisania

Powodem, dla którego | = nie skraca się, jest to, że robi bitowe lub nie logiczne OR. To znaczy:

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

Tutorial dla operatorów Javy

To stary post, ale w celu zapewnienia innej perspektywy dla początkujących, chciałbym podać przykład.

Myślę, że najczęstszym przypadkiem użycia podobnego operatora złożonego byłoby +=. Jestem pewien, że wszyscy napisaliśmy coś takiego:

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

Jaki był tego cel? Miało to na celu uniknięcie dwukrotnego zapisu zmiennej a w tej samej linii. (Czy brakuje mi tu czegoś lepszego?)

Więc następny wiersz robi dokładnie to samo, unikając wpisywania zmiennej b1 dwa razy w ta sama linia.

b1 |= b2;