Чому у Java немає складених версій присвоєння операторів conditional-and and conditional-or? (&& =, || =)

Так що для бінарних операторів в булевих, Java має &, |, ^, &&і ||.

Давайте коротко підсумуємо, що вони тут коротко роблять:

• JLS 15.22.2 Логічні логічні оператори &, ^ та |
• JLS 15.23 Умовно-оператор &&
• JLS 15.24 Умовно-оператор ||

Адже &значення результату - це, trueякщо обидва значення операнда є true; в іншому випадку результат є false.

Адже |значення результату - це, falseякщо обидва значення операнда є false; в іншому випадку результат є true.

Бо ^значення результату - це trueякщо значення операнда різні; в іншому випадку результат є false.

&&Оператор подібний , &але оцінює її правий операнд тільки , якщо значення його лівого операнда є true.

||Оператор подібний |, але оцінює її правий операнд тільки , якщо значення його лівого операнда є false.

Зараз серед усіх 5, 3 з них мають складені версії присвоєння, а саме |=, &=і ^=. Тож моє запитання очевидне: чому Java не надає, &&=а ||=також? Я вважаю , що мені потрібно більше , ніж ті , які мені потрібні &=і |=.

І я не думаю, що "тому що це занадто довго" - це хороша відповідь, тому що Java має >>>=. Для цього упущення має бути краща причина.

З 15.26 Оператори присвоєння :

Існує 12 операторів присвоєння; [...]= *= /= %= += -= <<= >>= >>>= &= ^= |=

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

З 15.26.2 Оператори складеного призначення :

Складений вираз присвоєння форми E1 op= E2еквівалентний E1 = (T)((E1) op (E2)), де T- тип E1, за винятком того, що E1обчислюється лише один раз.

Як доказ, наступний фрагмент кидає a NullPointerException, а не an ArrayIndexOutOfBoundsException.

    int[] a = null;
    int[] b = {};
    a[0] += b[-1];

Причина

Оператори &&=та ||=недоступні на Java, оскільки для більшості розробників такими операторами є:

• схильний помилятися
• марно

Приклад для &&=

Якщо Java дозволена &&=оператору, то цей код:

bool isOk = true; //becomes false when at least a function returns false
isOK &&= f1();
isOK &&= f2(); //we may expect f2() is called whatever the f1() returned value

було б еквівалентно:

bool isOk = true;
if (isOK) isOk = f1();
if (isOK) isOk = f2(); //f2() is called only when f1() returns true

Цей перший код схильний до помилок, оскільки багато розробників вважають, що f2()його завжди називають незалежно від поверненого значення f1 (). Це як bool isOk = f1() && f2();де f2()викликається лише тоді, коли f1()повертається true.

Якщо розробник хоче, f2()щоб його викликали лише тоді, коли він f1()повертається true, отже другий код вище менш схильний до помилок.

В іншому &=достатньо, оскільки розробник хоче, f2()щоб його завжди називали:

Той самий приклад, але для &=

bool isOk = true;
isOK &= f1();
isOK &= f2(); //f2() always called whatever the f1() returned value

Більше того, JVM повинен запускати цей наведений вище код як такий:

bool isOk = true;
if (!f1())  isOk = false;
if (!f2())  isOk = false;  //f2() always called

Порівняйте &&та отримайте &результати

Чи є результати операторів &&і &той же , коли застосовується на булевих значень?

Давайте перевіримо, використовуючи такий код Java:

public class qalcdo {

    public static void main (String[] args) {
        test (true,  true);
        test (true,  false);
        test (false, false);
        test (false, true);
    }

    private static void test (boolean a, boolean b) {
        System.out.println (counter++ +  ") a=" + a + " and b=" + b);
        System.out.println ("a && b = " + (a && b));
        System.out.println ("a & b = "  + (a & b));
        System.out.println ("======================");
    }

    private static int counter = 1;
}

Вихід:

1) a=true and b=true
a && b = true
a & b = true
======================
2) a=true and b=false
a && b = false
a & b = false
======================
3) a=false and b=false
a && b = false
a & b = false
======================
4) a=false and b=true
a && b = false
a & b = false
======================

Тому ТАК , ми можемо замінити &&на &для логічних значень ;-)

Так що краще використовувати &=замість &&=.

Те саме для ||=

Ті самі причини, що і для &&=:
оператор |=менш схильний до помилок, ніж ||=.

Якщо розробник хоче, f2()щоб його не викликали при f1()поверненні true, я раджу наступні альтернативи:

// here a comment is required to explain that 
// f2() is not called when f1() returns false, and so on...
bool isOk = f1() || f2() || f3() || f4();

або:

// here the following comments are not required 
// (the code is enough understandable)
bool isOk = false;
if (!isOK) isOk = f1();
if (!isOK) isOk = f2(); //f2() is not called when f1() returns false
if (!isOK) isOk = f3(); //f3() is not called when f1() or f2() return false
if (!isOK) isOk = f4(); //f4() is not called when ...

Можливо тому, що щось на зразок

x = false;
x &&= someComplexExpression();

схоже, це повинно бути присвоєння xта оцінка someComplexExpression(), але той факт, що оцінка залежить від вартостіx , не видно з синтаксису.

Також тому, що синтаксис Java базується на C, і ніхто не бачив нагальної потреби додавати ці оператори. Вам, мабуть, було б краще із заявою if, у будь-якому випадку.

Це так у Java, бо саме так у C.

Тепер питання, чому це так в С, полягає в тому, що коли & та && стали різними операторами (колись передуючи спуску С з В), різноманітність операторів & = просто не помічали.

Але у другій частині моєї відповіді немає жодних джерел, що підтверджують це.

Значною мірою тому, що синтаксис Java базується на C (або принаймні на сімействі C), і в C всі ці оператори присвоєння компілюються в арифметичні або побітові інструкції збірки в одному регістрі. Версія оператора присвоєння уникає тимчасових подій і, можливо, створила більш ефективний код для ранніх неоптимізуючих компіляторів. Логічний оператор (як вони називаються на С) еквіваленти ( &&=і||= ) не мають такої очевидної відповідності єдиним інструкціям зі складання; вони зазвичай розширюються до тестової та розгалуженої послідовності інструкцій.

Цікаво, що такі мови, як рубін , мають || = та && =.

Редагувати: термінологія відрізняється між Java та C

Однією з початкових цілей Java було бути "Простий, об'єктно-орієнтований і звичний". Що стосується цього випадку, & = є знайомим (C, C ++ це має і знайоме в цьому контексті означає знайоме тому, хто знає цих двох).

&& = не було б знайомим і не було б простим, в тому сенсі, що дизайнери мов не прагнули продумати кожен оператор, який вони могли б додати до мови, тому менше додаткових операторів простіше.

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

Замість того, щоб писати

foreach(item in coll)
{
   bVal = bVal || fn(item); // not so elegant
}

Я хочу писати

foreach(item in coll)
{
  bVal ||= fn(item);    // elegant
}

і знайте, що після того, як bVal істинно, fn () не буде викликатися протягом решти ітерацій.

' &' та ' &&' - не те саме, що ' &&' - це операція швидкого скорочення, яка не буде виконуватися, якщо перший операнд хибний, тоді як ' &' все одно зробить це (працює як з числом, так і з логічним значенням).

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

Дійсно не можу придумати, чому.

Це дозволено в Ruby.

Якби я здогадався, я б сказав, що він не часто використовується, тому не був реалізований. Іншим поясненням може бути те, що синтаксичний аналізатор дивиться на символ лише перед символом =

Я не можу придумати кращої причини, ніж тоді: "Це виглядає неймовірно потворно!"

&

перевіряє обидва операнди, це побітовий оператор. Java визначає кілька побітових операторів, які можна застосувати до цілочисельних типів, long, int, short, char та byte.

&&

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

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

Наявність оператора присвоєння && = насправді не додасть нової функціональності мові. Порозрядна арифметика оператора набагато виразніша, ви можете робити цілу розрядну арифметику, яка включає в себе логічну арифметику. Логічні оператори можуть просто виконувати булеву арифметику.

Брайан Гетц (архітектор мови Java в Oracle) писав :

https://stackoverflow.com/q/2324549/ [це питання] показує, що існує зацікавленість у наявності цих операторів, і немає чітких аргументів, чому вони ще не існують. Отже, питання полягає в тому: чи обговорювала команда JDK раніше додавання цих операторів, і якщо так, то де причини проти їх додавання?

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

"Вага його ваги" повинна оцінюватися за її витратами та вигодами, а також за співвідношенням витрат і вигод щодо інших характеристик кандидата.

Думаю, ви неявно припускаєте (за фразою "є інтерес"), що вартість майже нульова, а вигода більша за нуль, тому видається очевидним виграшем. Але це заперечує неправильне розуміння вартості; така функція впливає на специфікацію мови, реалізацію, JCK та кожну IDE та підручник Java. Немає тривіальних мовних особливостей. І користь, хоча і ненульова, є досить невеликою.

По-друге, ми можемо робити нескінченно багато функцій , але ми маємо можливість робити кілька разів кожні кілька років (а користувачі мають обмежену здатність поглинати нові функції.) Тому ми повинні бути дуже обережними щодо того, який саме вибір ми вибираємо, оскільки кожна функція (навіть банальна, здавалося б) споживає частину цього бюджету і незмінно забирає його у інших.
Це не "чому не ця функція", а "які ще функції ми не будемо робити (або затримувати), щоб ми могли зробити цю, і чи є це хорошим обміном?" І я не можу собі уявити, що це хороша торгівля з чим-небудь ще, над чим ми працюємо.

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

a & b та a&& b - це не одне і те ж.

a && b - це булевий вираз, який повертає булеве значення, а a & b - побітове вираження, яке повертає int (якщо a та b є ints).

як ви думаєте, що вони однакові?