Ярлик оператора “or-assignment” (| =) в Java

Мені потрібно виконати довгий набір порівнянь на Java, і я хотів би знати, чи одне чи кілька з них виглядають як істинні. Рядок порівнянь був довгим і важким для читання, тому я розбив його для читабельності і автоматично перейшов використовувати оператор швидкого доступу, |=а не negativeValue = negativeValue || boolean.

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

Я сподіваюсь negativeValueбути істинним, якщо будь-яке із значень за замовчуванням <something> є негативними. Чи це дійсно? Чи зробить це те, що я очікую? Я не міг побачити, як це згадується на веб-сайті Sun або stackoverflow, але Eclipse, схоже, не має проблем із цим, і код компілюється та запускається.

Так само, якби я хотів виконати кілька логічних перетинів, чи міг би я використовувати &=замість цього &&?

|=Є оператором присвоювання з'єднання ( ПСБ 15.26.2 ) для логічного логічного оператора |( ПСБ 15.22.2 ); не плутати з умовно-або ||( JLS 15.24 ). Існують також &=і ^=відповідні складеному призначенню версія логічного логічного &і ^відповідно.

Іншими словами, для boolean b1, b2цих двох рівнозначно:

 b1 |= b2;
 b1 = b1 | b2;

Різниця між логічними операторами ( &і |) порівняно з їх умовними аналогами ( &&і ||) полягає в тому, що перші не "замикають"; останні роблять. Це є:

• &і | завжди оцінювати обидва операнди
• &&і умовно|| оцінити правий операнд ; правильний операнд обчислюється лише в тому випадку, якщо його значення може вплинути на результат двійкової операції. Це означає, що правильний операнд НЕ обчислюється, коли:
  • Лівий операнд &&оцінює доfalse
    • (бо незалежно від того, до чого оцінює правий операнд, весь вираз false)
  • Лівий операнд ||оцінює доtrue
    • (бо незалежно від того, до чого оцінює правий операнд, весь вираз true)

Отже, повертаючись до вашого початкового запитання, так, ця конструкція є дійсною, і хоча |=це не зовсім еквівалентний ярлик для, =і ||вона обчислює те, що ви хочете. Оскільки правою частиною |=оператора у вашому користуванні є проста операція порівняння цілих чисел, той факт, що |не замикається, є незначним.

Бувають випадки, коли коротке замикання бажане або навіть потрібне, але ваш сценарій не є одним із них.

Прикро, що на відміну від деяких інших мов, Java не має &&=і ||=. Це обговорювалось у питанні, чому Java не має складених версій присвоєння операторів conditional-and and conditional-or? (&& =, || =) .

Це не оператор "ярлика" (або короткого замикання) таким чином, що || та && є (оскільки вони не будуть оцінювати 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;

Для найпростіших виразів використання |може бути швидшим, ніж ||тому, що хоча воно і уникає порівняння, це означає неявне використання гілки, а це може бути в рази дорожче.

Хоча це може бути надмірним для вашої проблеми, бібліотека Guava має хороший синтаксис з Predicates і виконує оцінку короткого замикання або / і Predicates.

По суті, порівняння перетворюються на об’єкти, упаковуються у колекцію, а потім повторюються. Для або предикатів перше справжнє звернення повертається з ітерації, і навпаки для і.

Якщо мова йде про читабельність, у мене є концепція відокремлення перевірених даних від логіки тестування. Зразок коду:

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

Він читабельніший, ніж "рядок порівняння", а також має перевагу у виконанні короткого замикання (ціною виділення масиву та виклику методу).

Редагувати: Ще більшої читабельності можна просто досягти, використовуючи параметри varargs:

Підпис методу буде таким:

boolean checkIfAnyNegative(DataType ... data)

А дзвінок міг виглядати так:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

Це стара публікація, але для того, щоб запропонувати інший погляд на початківців, я хотів би навести приклад.

Я думаю, що найпоширенішим варіантом використання подібного складеного оператора буде +=. Я впевнений, що ми всі писали щось подібне:

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

Який сенс у цьому був? Суть полягала в тому, щоб уникнути шаблону та усунути повторюваний код.

Отже, наступний рядок робить точно те саме, уникаючи введення змінної b1двічі в одному рядку.

b1 |= b2;

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

|| логічне логічне АБО
| побітове АБО

| = побітове включення АБО та оператор присвоєння

Причина, по якій | = не є короткою схемою, полягає в тому, що вона виконує побітове АБО не логічне АБО. Тобто:

C | = 2 те саме, що C = C | 2

Підручник для операторів Java