Dlaczego zwykle używamy / / over/? Co za różnica?

| nie wykonuje oceny zwarcia w wyrażeniach logicznych. || przestanie oceniać, czy pierwszy operand jest prawdziwy, ale | nie będzie.

Dodatkowo, | może być użyty do wykonania operacji bitowej-lub na wartościach byte/short/int/long. Nie mogę.

Aby więc bazować na innych odpowiedziach na przykładzie, zwarcie jest kluczowe w następujących testach obronnych:

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

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

Użycie | i & zamiast tego może spowodować NullPointerException rzucony tutaj.

Logiczne || i && sprawdzają prawą stronę tylko w razie potrzeby. | i & sprawdzają obie strony za każdym razem.

Na przykład:

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

Przepisz to:

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

Inny przykład:

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

Przepisz to:

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
...

Zwróć również uwagę na częstą pułapkę: operatorzy nie leniwi mają pierwszeństwo przed leniwymi, więc:

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

Oprócz zwarcia, należy pamiętać o tym, że wykonanie operacji logicznej bitowej na wartościach, które mogą być inne niż 0 LUB 1, ma zupełnie inne znaczenie niż logika warunkowa. Podczas gdy zwykle jest to takie samo dla | i ||, z & i && otrzymujesz bardzo różne wyniki (np. 2 & 4 jest 0/false, a 2 && 4 jest 1/true).

Jeśli to, co otrzymujesz z funkcji, jest kodem błędu i testujesz na nie-0-ness, może to mieć znaczenie Nr serii

Nie jest to tak duży problem w Javie, gdzie trzeba jawnie typecast do boolean lub porównać z 0 lub tym podobne, ale w innych językach o podobnej składni (C/C++ i in.) może to być dość mylące.

Zauważ również, że & i / mogą dotyczyć tylko wartości typu integer, a nie wszystkiego, co może być równoważne testowi logicznemu. Ponownie, w językach innych niż Java, istnieje sporo rzeczy, które mogą być używane jako boolean z ukrytym porównaniem != 0 (wskaźniki, pływaki, obiekty z operator bool(), itp.) i operatory bitowe są prawie zawsze bezsensowne w tych kontekstach.

Jedyny czas, kiedy użyjesz | LUB & zamiast || lub && jest wtedy, gdy masz bardzo proste wyrażenia logiczne, a koszt krótkiego cięcia (np. gałęzi) jest większy niż czas, który zaoszczędzisz, nie oceniając późniejszych wyrażeń.

Jest to jednak mikro-optymalizacja, która rzadko ma znaczenie, z wyjątkiem kodu najniższego poziomu.

/ / jest operatorem logicznym OR, podczas gdy / jest operatorem bitowym or.

boolean a = true;
boolean b = false;

if (a || b) {
}

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

A/ b: Oceń b w any case

A / / b: evaluate b only if a evaluates to false

Oprócz faktu, że | jest operatorem bitowym: / / jest operatorem zwarciowym-gdy jeden element jest fałszywy, nie sprawdzi pozostałych.

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

Jeśli coś jest prawdą | / / nie oceni czegoś innego, podczas gdy / zrobi. Jeśli zmienne w instrukcji if są w rzeczywistości wywołaniami funkcji, użycie | / może zaoszczędzić sporo wydajności.

| is the binary or operator

|| is the logic or operator

Operatory

|| i && nazywane są operatorami warunkowymi , natomiast operatory bitowe | i & nazywane są operatorami bitowymi {7]}. Służą różnym celom.

Operatory warunkowe działają tylko z wyrażeniami, które statycznie oceniają do boolean po obu stronach lewej i prawej strony.

Operatory bitowe działają z dowolnymi operandami liczbowymi.

Jeśli chcesz wykonać logiczne porównanie, powinieneś użyć operatorów warunkowych , ponieważ dodasz kilka rodzaj bezpieczeństwa wpisz swój kod.

A side note: Java ma / = ale nie an / / =

Przykładem, kiedy musisz użyć || jest sytuacja, gdy pierwsze wyrażenie jest testem, aby sprawdzić, czy drugie wyrażenie nie wybuchnie. np. użycie pojedynczego / w przypadku hte może skutkować NPE.

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

Inne odpowiedzi wykonały dobrą robotę, pokrywając funkcjonalną różnicę między operatorami, ale odpowiedzi mogą dotyczyć prawie każdego języka wywodzącego się z języka C istniejącego obecnie. Pytanie jest oznaczone java , więc postaram się odpowiedzieć konkretnie i technicznie dla języka Java.

& i | mogą być Całkowymi operatorami bitowymi lub logicznymi operatorami logicznymi. Składnia operatorów bitowych i logicznych (§15.22) jest:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

Składnia dla EqualityExpression jest zdefiniowana w §15.21, która wymaga RelationalExpression zdefiniowanego w §15.20, co z kolei wymaga ShiftExpression i ReferenceType zdefiniowanych w §15.19 oraz §4.3, odpowiednio. ShiftExpression wymaga AdditiveExpression zdefiniowanego w §15.18, który nadal drąży, definiując podstawowe operatory arytmetyczne, jednoargumentowe itp. ReferenceType ćwiczy w dół do wszystkich różnych sposobów reprezentowania typu. (Podczas gdy {[7] } nie obejmuje typy prymitywne, definicja typów prymitywnych jest ostatecznie wymagana, ponieważ mogą one być typem wymiarowym dla tablicy, która jest a ReferenceType.)

Operatory bitowe i logiczne mają następujące właściwości:

• te operatory mają inny priorytet, z {[2] } mają najwyższy priorytet i | najniższy priorytet.
• każdy z tych operatorów jest składniowo lewy-asocjacyjny (każda grupa od lewej do prawej).
• każdy operator jest przemienny, jeśli Wyrażenia operand nie mają skutków ubocznych.
• każdy operator jest asocjacyjny.
• operatory bitowe i logiczne mogą być użyte do porównania dwóch operandów typu numerycznego lub dwóch operandów typu boolean. Wszystkie inne przypadki powodują błąd w czasie kompilacji.

Rozróżnienie między operatorem bitowym a operatorem logicznym zależy od tego, czy operandy są "kabriolet" (§4.2) lub jeśli są typu boolean lub Boolean (§5.1.8).

Jeśli operandy są typami całkowitymi, binarna promocja liczbowa(§5.6.2) jest wykonywana na obu operandach, pozostawiając je obie jako longs lub intS dla operacji. Typ operacji będzie typem (promowanych) operandów. W tym momencie, {[2] } będzie bitowe i, ^ będzie bitowe wyłączne OR, I {[3] } będzie bitowe inclusive lub. (§15.22.1)

Jeśli operandami są boolean lub Boolean, to w razie potrzeby zostaną one poddane konwersji unboxingu (§5.1.8), A Typ operacji będzie boolean. {[2] } spowoduje true, jeśli oba operandy są true, ^ spowoduje to true, jeśli oba operandy są różne, a | spowoduje to true, jeśli któryś z operandów jest true. (§15.22.2)

In contrast, && jest " warunkowe-i Operator" (§15.23) i || jest "operatorem warunkowym-lub" (§15.24). Ich składnia jest zdefiniowana jako:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&& jest podobny do &, z tą różnicą, że ocenia prawy operand tylko wtedy, gdy lewy operand to true. {[35] } jest podobne do |, z tą różnicą, że ocenia prawy operand tylko wtedy, gdy lewy operand to false.

Warunkowy-i ma następujące właściwości:

• operator warunkowy-i jest składniowo lewy-asocjacyjny(grupuje od lewej do prawej).
• operator warunkowy-i jest w pełni asocjacyjny zarówno w odniesieniu do efektów ubocznych, jak i wartości wyniku. Czyli dla dowolnych wyrażeń a, b, i c, ocena wyrażenia ((a) && (b)) && (c) daje ten sam wynik, z tymi samymi skutkami ubocznymi zachodzącymi w tej samej kolejności, co ocena wyrażenia (a) && ((b) && (c)).
• każdy operand operatora warunkowego i musi być typu boolean lub Boolean, lub kompilacji występuje błąd.
• typem wyrażenia warunkowego-i jest zawsze boolean.
• w czasie wykonywania, wyrażenie operandu lewej strony jest oceniane jako pierwsze; jeśli wynik ma typ Boolean, jest poddawany konwersji unboxing (§5.1.8).
• jeśli wartością wynikową jest false, wartość wyrażenia warunkowego-and wynosi false, A prawostronne wyrażenie operandowe nie jest oceniane.
• jeśli wartość lewego operandu wynosi true, następnie jest obliczane wyrażenie prawej ręki; jeżeli wynik ma typ Boolean, jest poddawany konwersji unboxing (§5.1.8). Wartość wynikowa staje się wartością wyrażenia warunkowego-and.
• zatem && oblicza ten sam wynik co & na operandach boolean. Różni się tylko tym, że wyrażenie operandu prawej ręki jest oceniane warunkowo, a nie zawsze.

Warunkowe-lub ma następujące właściwości:

• operator warunkowy-or jest składniowo lewy-asocjacyjny (grupuje od lewej do prawej).
• operator warunkowy-or jest w pełni asocjacyjny zarówno w odniesieniu do efektów ubocznych, jak i wartości wyniku. Czyli dla dowolnych wyrażeń a, b, i c, ocena wyrażenia ((a) || (b)) || (c) daje ten sam wynik, z tymi samymi skutkami ubocznymi zachodzącymi w tej samej kolejności, co ocena wyrażenia (a) || ((b) || (c)).
• każdy operand warunkowego-lub operator musi być typu boolean lub Boolean, w przeciwnym razie wystąpi błąd w czasie kompilacji.
• typem wyrażenia warunkowego-lub jest zawsze boolean.
• w czasie wykonywania, wyrażenie operandu lewej strony jest oceniane jako pierwsze; jeśli wynik ma typ Boolean, jest poddawany konwersji unboxing (§5.1.8).
• jeśli wartością wynikową jest true, wartość wyrażenia warunkowego-or wynosi true, a wyrażenie operandu prawej strony nie jest oceniane.
• jeśli wartość operandu lewej ręki wynosi false, wtedy jest obliczane wyrażenie prawej ręki; jeśli wynik ma typ Boolean, jest poddawany konwersji unboxingu (§5.1.8). Wartość wynikowa staje się wartością wyrażenia warunkowego-lub.
• zatem || oblicza ten sam wynik co | na boolean lub Boolean operandach. Różni się tylko tym, że wyrażenie operandu prawej ręki jest oceniane warunkowo, a nie zawsze.

W krótko, jak @JohnMeagher wielokrotnie podkreślał w komentarzach, & i | są w rzeczywistości operatorami boolean nie zwartymi w konkretnym przypadku, gdy operandami są boolean lub Boolean. Przy dobrych praktykach (tj. bez efektów wtórnych) jest to niewielka różnica. Jednak, gdy operandy nie są booleans lub Booleans, operatory zachowują się bardzo inaczej: operacje bitowe i logiczne po prostu nie porównują się dobrze na wysokim poziomie programowania w Javie.

1).(ekspresja1 | ekspresja2), operator / oceni ekspresja2 niezależnie od tego, czy wynik wyrażenia jest prawdziwy czy fałszywy.

Przykład:

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).(wyrażenie1 || wyrażenie2), || operator nie będzie oceniał wyrażeń2, jeśli wyrażenie1 jest prawdziwe.

Przykład:

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

|| Zwraca wartość logiczną przez OR ' ING dwie wartości (dlatego jest ona znana jako logiczne or)

IE:

if (A || B) 

Zwróci true, Jeśli a lub B jest prawdziwe, lub false, jeśli oba są fałszywe.

| jest operatorem, który wykonuje operację bitową na dwóch wartościach. Aby lepiej zrozumieć operacje bitowe, możesz przeczytać tutaj:

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

Główną różnicą jest to, że || i && wykazują "zwarcie", więc RHS będzie oceniane tylko w razie potrzeby.

Dla np.

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

Powyżej Jeśli a jest prawdziwe, to b nie będzie testowane i zostanie wykonana ścieżka 1. Jeśli użyto|, to obie strony zostaną ocenione, nawet jeśli' a ' jest prawdziwe.

Zobacz tutaj i tutaj , aby uzyskać trochę więcej informacji.

Brak zwarcia może być przydatny. Czasami chcesz się upewnić, że dwa wyrażenia oceniają. Załóżmy na przykład, że masz metodę, która usuwa obiekt z dwóch oddzielnych list. Możesz chcieć zrobić coś takiego:

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

Jeśli twoja metoda zamiast tego użyła operandu warunkowego, nie usunie obiektu z drugiej listy, jeśli pierwsza lista zwróci wartość false.

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

Nie jest niezwykle przydatny i (jak w przypadku większości zadań programistycznych) można go osiągnąć innymi środkami. Ale jest to przypadek użycia dla bitowych operandów.

Podstawowa różnica między nimi polega na tym, że | najpierw konwertuje wartości na binarne, a następnie wykonuje operację bit wise or. Tymczasem | / nie konwertuje danych na binarne, a jedynie wykonuje wyrażenie or NA oryginalnym stanie.

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

Czytaj więcej: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

Kiedy miałem takie pytanie, stworzyłem kod testowy, aby się o tym przekonać.

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

 }
}

W tym przypadku zmieniamy tylko lewostronną wartość warunku if dodając a lub b.

|| scenariusz, gdy lewa strona true [if (a / / bool ())]

Wyjście "If condition executed"

|| Scenario, when left side false [if (B / / bool ())]

Wyjście -

Bool
If condition executed

Conclusion of || przy użyciu ||, Prawa strona sprawdza tylko, gdy lewa strona jest fałsz.

| scenariusz, gdy lewa strona true [if (a / bool ())]

Wyjście -

Bool
If condition executed

| Scenario, when left side false [if (B / bool ())]

Wyjście -

Bool
If condition executed

Conclusion of | podczas używania | należy sprawdzić zarówno lewą, jak i prawą stronę.

| = bitowe or | / / = logiczne or

Zwykle używam, gdy istnieje operator Pre increment i post increment. Spójrz na następujący kod:

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

Wyjście:

Wydrukuje się w pierwszej kolejności, jeśli
I is: 11

drukuje w sekundach, jeśli
x jest: 10

Oba if bloki są takie same, ale wynik jest inny. gdy istnieje |, oba warunki zostaną ocenione. Ale jeśli jest ||, nie oceni drugiego warunku, ponieważ pierwszy warunek jest już prawdziwy.

Istnieje wiele przypadków użycia sugerujących, dlaczego powinieneś wybrać || zamiast |. Niektóre przypadki użycia muszą użyć operatora |, aby sprawdzić wszystkie warunki.

Na przykład, jeśli chcesz sprawdzić walidację formularza i chcesz pokazać użytkownikowi Wszystkie nieprawidłowe pola z tekstami błędów, a nie tylko pierwsze nieprawidłowe pole.

|| operator będzie,

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

Tak więc z powyższym fragmentem, jeśli użytkownik przesyła formularz ze wszystkimi pustymi polami, tylko nameField zostanie wyświetlony komunikat o błędzie. Ale jeśli zmienisz go na,

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

Wyświetli właściwy komunikat o błędzie w każdym polu niezależnie od warunków true.

Po uważnym przeczytaniu tego tematu nadal nie jest dla mnie jasne, czy używanie | jako operatora logicznego jest zgodne z praktykami wzorców Javy.

Ostatnio zmodyfikowałem kod w pull request adresując komentarz gdzie

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

Należało zmienić na

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

Jaka jest aktualna akceptowana wersja?

Dokumentacja Javy jest , a nie wspominaniem | jako logicznego nie-skrótu lub operatora.

|| jest logicznym or i / jest bitowym OR.

Operatory Java

| jest bitowym or, / / jest logicznym OR.

Spójrz na:

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

/ jest bitowo włącznie lub

/ / jest logiczne lub

| jest operatorem bitowym. / / jest operatorem logicznym.

Jeden zajmie dwa bity i albo je.

Ktoś określi prawdę (to lub tamto) jeśli to prawda lub tamto, to odpowiedź jest prawdziwa.