Чому ми зазвичай використовуємо || понад |? Яка різниця?

Мені просто цікаво, чому ми зазвичай використовуємо логічну АБО ||між двома булевими, а не побітними АБО |, хоча вони обидва працюють добре.

Я маю на увазі, подивіться на наступне:

if(true  | true)  // pass
if(true  | false) // pass
if(false | true)  // pass
if(false | false) // no pass

if(true  || true)  // pass
if(true  || false) // pass
if(false || true)  // pass
if(false || false) // no pass

Чи можемо ми використовувати |замість ||? Те саме &і з &&.

Якщо ви використовуєте оператори ||та &&форми, а не форми |та &форми цих операторів, Java не буде заважати оцінювати правий операнд самостійно.

Справа в тому, хочете ви коротко замикати оцінку чи ні - більшу частину часу хочете.

Хорошим способом проілюструвати переваги короткого замикання було б розглянути наступний приклад.

Boolean b = true;
if(b || foo.timeConsumingCall())
{
   //we entered without calling timeConsumingCall()
}

Ще одна перевага, як згадували Джеремі та Пітер, для короткого замикання - це нульова контрольна перевірка:

if(string != null && string.isEmpty())
{
    //we check for string being null before calling isEmpty()
}

більше інформації

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

Крім того, |може використовуватися для виконання побітових операцій АБО за значеннями байт / короткий / int / long. ||не може.

Тож просто спираючись на інші відповіді на прикладі, коротке замикання має вирішальне значення при наступних оборонних перевірках:

if (foo == null || foo.isClosed()) {
    return;
}

if (bar != null && bar.isBlue()) {
    foo.doSomething();
}

Використання |та &замість цього може призвести до NullPointerExceptionтого, що сюди кинуть.

Логічно ||і &&перевіряйте праву частину лише за потреби. Кожен раз |і &перевіряйте обидві сторони.

Наприклад:

int i = 12;
if (i == 10 & i < 9) // It will check if i == 10 and if i < 9
...

Перепишіть його:

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i != 10
...

Ще один приклад:

int i = 12;
if (i == 12 | i > 10) // It will check if i == 12 and it will check if i > 10
...

Перепишіть його:

int i = 12;
if (i == 12 || i > 10) // It will check if i == 12, it does, so it stops checking and executes what is in the if statement
...

Також зауважте загальну проблему: неліниві оператори мають перевагу перед ледачими, тому:

boolean a, b, c;
a || b && c; //resolves to a || (b && c)
a | b && c; //resolves to (a | b) && c

Будьте обережні, перемішуючи їх.

Окрім короткого замикання, слід пам’ятати ще й те, що виконання побітової логічної операції над значеннями, які можуть бути іншими, ніж 0 або 1, має зовсім інше значення, ніж умовна логіка. Хоча це НАЗАГАЛЬНО те саме |і для ||, з &і &&ви отримуєте дуже різні результати (наприклад 2 & 4, 0 / помилковий час2 && 4 1 / правда).

Якщо те, що ви отримуєте від функції, насправді є кодом помилки, і ви тестуєте на не-0-ность, це може мати велике значення.

Це не так багато проблем на Яві, де вам потрібно явно набрати на булевий або порівняти з 0 або подібним, але в інших мовах з подібним синтаксисом (C / C ++ та ін.) Це може бути дуже заплутано.

Також зауважте, що & і | може застосовуватися лише до значень цілого типу, а не до всього, що може бути еквівалентним булевим тестом. Знову ж таки, в мовах, що не є Java, є досить багато речей, які можна використовувати як булеві дані з неявним != 0порівнянням (покажчики, поплавці, об'єкти з і operator bool()т. Д.), А побітові оператори майже завжди безглузді в цих контекстах.

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

Однак це мікрооптимізація, яка рідко має значення, за винятком коду самого низького рівня.

|| є логічним або оператором під час | є бітовим або оператором.

boolean a = true;
boolean b = false;

if (a || b) {
}

int a = 0x0001;
a = a | 0x0002;

а | b: оцінювати b в будь-якому випадку

а || b: оцінюйте b лише в тому випадку, якщо оцінюється на false

Крім того, що | є побітовим оператором: || є оператором короткого замикання - коли один елемент помилковий, він не перевірятиме інші.

 if(something || someotherthing)
 if(something | someotherthing)

якщо щось ІСТИНА, || не оцінюватиме щось інше, тоді як | зроблю. Якщо змінні у ваших if-операторах насправді викликають функцію, використовуючи || можливо, економить велику продуктивність.

| is the binary or operator

|| is the logic or operator

Оператори ||і &&називаються умовними операторами , тоді як |і &називаються побітовими операторами . Вони служать різним цілям.

Умовні оператори працюють лише з виразами, які статично оцінюються як booleanна лівій, так і на правій стороні.

Побітові оператори працюють з будь-якими числовими операндами.

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

Побічна примітка: Java має | =, але не || =

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

public static boolean isNotSet(String text) {
   return text == null || text.length() == 0;
}

Інші відповіді вдало вирішили розкрити функціональну різницю між операторами, але відповіді можуть стосуватися майже кожної окремо взятої мови С, яка існує сьогодні. Питання позначено тегомjava, і тому я постараюся відповісти спеціально та технічно на мові Java.

&і |можуть бути або операторами побітових розрядів, або булевими логічними операторами. Синтаксис бітових та логічних операторів ( §15.22 ):

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

Синтаксис для EqualityExpressionвизначений у § 15.21 , що вимагає RelationalExpressionвизначення у § 15.20 , що, у свою чергу, вимагає ShiftExpressionта ReferenceTypeвизначено відповідно у § 15.19 та §4.3 . ShiftExpressionвимагає AdditiveExpressionвизначеного в § 15.18 , який продовжує свердлити, визначаючи основні арифметичні, одинарні оператори тощо ReferenceType. (Хоча ReferenceTypeне включає примітивні типи, в остаточному підсумку визначається визначення примітивних типів, оскільки вони можуть бути типом виміру для масиву, який є a ReferenceType.)

Бітові та логічні оператори мають такі властивості:

• Ці оператори мають різний пріоритет, &мають найвищий пріоритет і |найнижчий пріоритет.
• Кожен з цих операторів є синтаксично ліво-асоціативним (кожна група зліва направо).
• Кожен оператор є комутативним, якщо вирази операнда не мають побічних ефектів.
• Кожен оператор асоціативний.
• Побітові та логічні оператори можуть використовуватися для порівняння двох операндів числового типу або двох операндів типу boolean. Усі інші випадки призводять до помилки часу компіляції.

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

Якщо операнди є інтегральними типами, на обох операндах виконується двійкове числове просування ( §5.6.2 ), залишаючи їх як longs, так і ints для операції. Тип операції буде типом (просунутих) операндів. У цей момент &буде розрядне І, ^буде побітним винятком АБО, і |буде побітовим включенням АБО. ( §15.22.1 )

Якщо операнди є, booleanабо Booleanоперанди будуть підлягати конвертації розпакування, якщо це необхідно ( §5.1.8 ), і тип операції буде boolean. &це призведе до того, що trueобидва операнди є true, ^призведе до того, що trueобидва операнди різні, і |призведе до trueтого, що є будь-який операнд true. ( §15.22.2 )

Навпаки, && це "Умовно-І Оператор" ( §15.23 ) і ||є "Умовно-Або Оператор" ( §15.24 ). Їх синтаксис визначається як:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&є як &, за винятком того, що він оцінює правий операнд лише тоді, коли лівий операнд true. ||є як |, за винятком того, що він оцінює правий операнд лише тоді, коли лівий операндfalse .

Умовно-А має такі властивості:

• Умовно-оператор синтаксично ліво-асоціативний (він групується зліва направо).
• Умовно-оператор є повністю асоціативним щодо побічних ефектів та значення результату. Тобто, для будь-яких виразів a, bа також c, оцінка виразу ((a) && (b)) && (c)дає той самий результат із тими ж побічними ефектами, що виникають у тому ж порядку, що й оцінка виразу(a) && ((b) && (c)) .
• Кожен операнд умовного і оператора повинен бути типу booleanабоBoolean , або виникає помилка часу компіляції.
• Тип умовно-вираження завжди boolean .
• Під час виконання спочатку оцінюється вираз лівого операнду; якщо результат має тип Boolean, він піддається розгорнутому перетворенню ( §5.1.8 ).
• Якщо отримане значення дорівнює false, значення умовного і вираження єfalse а правий вираз операнда не оцінюється.
• Якщо значення лівого операнда дорівнює true, то вираження праворуч оцінюється; якщо результат має тип Boolean, він піддається розгорнутому перетворенню ( §5.1.8 ). Отримане значення стає значенням умовно-вираження.
• Таким чином, &&обчислюється той самий результат, що і &на booleanоперандах. Він відрізняється лише тим, що вираз правого операнда оцінюється умовно, а не завжди.

Умовно-Або має такі властивості:

• Умовно-або оператор синтаксично ліво-асоціативний (він групується зліва направо).
• Умовно-або оператор є повністю асоціативним щодо побічних ефектів та значення результату. Тобто, для будь-яких виразів a, bі c, оцінка вираження ((a) || (b)) || (c)дає той самий результат, з тими ж побічними ефектами, що виникають у тому ж порядку, що і оцінка виразу (a) || ((b) || (c)).
• Кожен операнд умовного або оператора повинен бути типу booleanабо Boolean, або виникає помилка часу компіляції.
• Тип умовного або виразу є завжди boolean .
• Під час виконання спочатку оцінюється вираз лівого операнду; якщо результат має тип Boolean, він піддається розгорнутому перетворенню ( §5.1.8 ).
• Якщо отримане значення є true, значення умовного або виразу є, trueа вираз правого операнда не оцінюється.
• Якщо значення лівого операнда дорівнює false, то вираження праворуч оцінюється; якщо результат має тип Boolean, він піддається розгорнутому перетворенню ( §5.1.8 ). Отримане значення стає значенням умовного або виразу.
• Таким чином, ||обчислює той же результат, |на booleanабо Booleanоперанди. Він відрізняється лише тим, що вираз правого операнда оцінюється умовно, а не завжди.

Коротше кажучи, як @JohnMeagher неодноразово вказував у коментарях, &і |насправді булові оператори, що не мають короткого замикання, у конкретному випадку операндів є booleanабо Boolean. При належній практиці (тобто відсутність вторинних наслідків) це незначна різниця. Однак, коли операндів немає booleanабо Booleanне, оператори поводяться зовсім інакше: побітові та логічні операції просто не дуже добре порівнюються на високому рівні програмування Java.

1). (Вираз1 | вираз2), | Оператор оцінить вираз2 незалежно від того, результат вираження1 є істинним чи хибним.

Приклад:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b | test());
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

2). (Вираз1 || вираз2), || Оператор не буде оцінювати izraz2, якщо вираз1 є істинним.

Приклад:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b || test())
        {
            System.out.println("short circuit!");
        }
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

|| повертає булеве значення OR'і два значення (Ось чому його відоме як ЛОГІЧНИЙ або)

IE:

if (A || B) 

Повертає істину, якщо або A, або B є істиною, або false, якщо вони обидва помилкові.

| є оператором, який виконує побітну операцію за двома значеннями. Щоб краще зрозуміти бітові операції, ви можете прочитати тут:

http://en.wikipedia.org/wiki/Bitwise_operation

Одна головна відмінність полягає в тому, що || і && демонструють "коротке замикання", тому РЗС буде оцінюватися лише за потреби.

Наприклад, наприклад

if (a || b) {
    path1...
} else {
    path2..
}

Якщо вище значення a, то b не перевірятиметься, а шлях1 виконується. Якщо | було використано, тоді обидві сторони будуть оцінені, навіть якщо "a" є правдою.

Для отримання додаткової інформації див. Тут і тут .

Сподіваюсь, це допомагає.

Некоротке замикання може бути корисним. Іноді хочеться переконатися, що два вирази оцінюють. Наприклад, скажімо, у вас є метод, який видаляє об'єкт з двох окремих списків. Ви можете зробити щось подібне:

class foo {

    ArrayList<Bar> list1 = new ArrayList<Bar>();
    ArrayList<Bar> list2 = new ArrayList<Bar>();

    //Returns true if bar is removed from both lists, otherwise false.
    boolean removeBar(Bar bar) {
        return (list1.remove(bar) & list2.remove(bar));
    }
}

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

//Fails to execute the second remove if the first returns false.
boolean removeBar(Bar bar) {
    return (list1.remove(bar) && list2.remove(bar));
}

Це не дивно корисно, і (як у більшості завдань програмування) ви могли досягти цього іншими засобами. Але це випадок використання для побітових операндів.

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

int two = -2; int four = -4;
result = two | four; // bitwise OR example

System.out.println(Integer.toBinaryString(two));
System.out.println(Integer.toBinaryString(four));
System.out.println(Integer.toBinaryString(result));

Output:
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111110

Детальніше: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

Коли у мене виникло це питання, я створив тестовий код, щоб зрозуміти це.

public class HelloWorld{

   public static boolean bool(){
      System.out.println("Bool");
      return true;
   }

   public static void main(String []args){

     boolean a = true;
     boolean b = false;

     if(a||bool())
     {
        System.out.println("If condition executed"); 
     }
     else{
         System.out.println("Else condition executed");
     }

 }
}

У цьому випадку ми змінюємо лише значення лівої сторони, якщо умова додає a або b.

|| Сценарій, коли ліва сторона істинна [if (a || bool ())]

вихід "If condition executed"

|| Сценарій, коли ліва сторона помилкова [if (b || bool ())]

Вихід-

Bool
If condition executed

Conclusion of || Під час використання ||правою стороною перевіряйте лише, коли ліва сторона помилкова.

| Сценарій, коли ліва сторона відповідає true [if (a | bool ())]

Вихід-

Bool
If condition executed

| Сценарій, коли ліва сторона помилкова [if (b | bool ())]

Вихід-

Bool
If condition executed

Conclusion of | Під час використання |перевіряйте і ліву, і праву сторону.

| = побіжно або, || = логіка або

Зазвичай я використовую, коли є оператор попереднього збільшення та збільшення. Подивіться на наступний код:

package ocjpPractice;
/**
 * @author tithik
 *
 */
public class Ex1 {

    public static void main(String[] args) {
    int i=10;
    int j=9;
    int x=10;
    int y=9;
    if(i==10 | ++i>j){
        System.out.println("it will print in first if");  
        System.out.println("i is: "+i);
    }

    if(x==10 ||++x>y){
        System.out.println("it will print in second if");   
        System.out.println("x is: "+x);
    }
    }
}

вихід:

він надрукується в першому, якщо
я є: 11

він буде надрукований у другому, якщо
х є: 10

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

Існує багато випадків використання, які підказують, чому слід їхати, ||а не робити |. У деяких випадках використання повинні використовувати |оператор , щоб перевірити всі умови.

Наприклад, якщо ви хочете перевірити перевірку форми і ви хочете показати користувачеві всі недійсні поля з текстами помилок, а не лише першим недійсним полем.

|| оператор буде,

   if(checkIfEmpty(nameField) || checkIfEmpty(phoneField) || checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

   private boolean checkIfEmpty(Widget field) {
      if(field.isEmpty()) {
        field.setErrorMessage("Should not be empty!");
        return true;
      }
      return false;
   }

Так що з вищевказаним фрагментом, якщо користувач подає форму із ВСІМ порожніми полями, ТОЛЬКО nameFieldвідображатиметься повідомлення з помилкою. Але, якщо змінити його,

   if(checkIfEmpty(nameField) | checkIfEmpty(phoneField) | checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

Він відображатиме належне повідомлення про помилку на кожному полі незалежно від trueумов.

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

Я нещодавно змінив код у запиті на виклик, звертаючись до коментаря, де

if(function1() | function2()){
  ...
}

довелося змінити на

boolean isChanged = function1();
isChanged |= function2();
if (isChanged){
  ...
}

Яка фактично прийнята версія?

Документація Java не згадується |як логічний оператор АБО, що не є коротким циклом.

Не зацікавлений у голосуванні, але більше у з'ясуванні стандарту ?! Обидві версії коду складаються та працюють як слід.

|| є логічним або і | є трохи розумним або.

Оператори Java

| порозрядно або, || є логічним або.

Подивись на:

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/operators.html

| біт включно АБО

|| логічно АБО

| є побітним оператором. || є логічним оператором.

Один візьме два біти та або їх.

Можна визначити істину (це АБО це) Якщо це правда чи це правда, то відповідь - правда.

Ох, і люди, що звикли, швидко відповідають на ці питання.