Perché usiamo di solito || oltre |? Qual è la differenza?

Mi chiedo solo perché di solito usiamo OR logico ||tra due valori booleani non bit a bit OR |, sebbene entrambi funzionino bene.

Voglio dire, guarda quanto segue:

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

Possiamo usare |invece di ||? Stessa cosa con &e &&.

Se si utilizzano i moduli ||e &&, anziché i moduli |e &di questi operatori, Java non si preoccuperà di valutare da solo l'operando di destra.

È una questione di se si desidera cortocircuitare la valutazione o meno, la maggior parte delle volte che si desidera.

Un buon modo per illustrare i vantaggi del corto circuito sarebbe quello di considerare il seguente esempio.

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

Un altro vantaggio, come menzionato da Jeremy e Peter, per il corto circuito è il controllo di riferimento null:

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

Ulteriori informazioni

| non esegue la valutazione di cortocircuito nelle espressioni booleane. ||smetterà di valutare se il primo operando è vero, ma |non lo farà.

Inoltre, |può essere utilizzato per eseguire l'operazione OR bit a bit su valori byte / short / int / long. ||non può.

Quindi, solo per basarsi sulle altre risposte con un esempio, il corto circuito è cruciale nei seguenti controlli difensivi:

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

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

L'uso di |e &invece potrebbe provocare un NullPointerExceptionlancio qui.

Logico ||e &&controllare il lato destro solo se necessario. La |e &verificare sia l'ogni lati.

Per esempio:

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

Riscriverlo:

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

Un altro esempio:

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

Riscriverlo:

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

Notare anche una trappola comune: gli operatori non pigri hanno la precedenza su quelli pigri, quindi:

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

Fai attenzione quando li mescoli.

Oltre al corto circuito, un'altra cosa da tenere a mente è che fare un'operazione di logica bit a bit su valori che possono essere diversi da 0 o 1 ha un significato molto diverso dalla logica condizionale. Mentre di solito è lo stesso per |e ||, con &e &&ottieni risultati molto diversi (ad es. 2 & 4È 0 / falso mentre 2 && 4è 1 / vero).

Se la cosa che stai ricevendo da una funzione è in realtà un codice di errore e stai testando la non-0-ness, questo può importare molto.

Questo non è un grosso problema in Java in cui devi esplicitamente digitare in booleano o confrontarlo con 0 o simili, ma in altre lingue con sintassi simile (C / C ++ et al) può essere abbastanza confuso.

Inoltre, nota che & e | può essere applicato solo a valori di tipo intero e non a tutto ciò che può essere equivalente a un test booleano. Ancora una volta, in linguaggi non Java, ci sono alcune cose che possono essere usate come booleane con un != 0confronto implicito (puntatori, float, oggetti con un operator bool(), ecc.) E gli operatori bit a bit sono quasi sempre privi di senso in quei contesti.

L'unica volta che vorresti usare |o &invece di ||o &&è quando hai espressioni booleane molto semplici e il costo della scorciatoia (cioè un ramo) è maggiore del tempo che risparmi non valutando le espressioni successive.

Tuttavia, questa è una micro-ottimizzazione che raramente conta tranne nel codice di livello più basso.

|| è il logico o l'operatore mentre | è bit a bit o operatore.

boolean a = true;
boolean b = false;

if (a || b) {
}

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

a | b: valuta b in qualsiasi caso

a || b: valuta b solo se a viene valutato falso

Oltre al fatto che | è un operatore bit a bit: || è un operatore di corto circuito - quando un elemento è falso, non controllerà gli altri.

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

se qualcosa è VERO, || non valuterà altro, mentre | andrà bene. Se le variabili nelle istruzioni if ​​sono effettivamente chiamate di funzione, usando || sta probabilmente risparmiando molte prestazioni.

| is the binary or operator

|| is the logic or operator

Gli operatori ||e &&sono chiamati operatori condizionali , mentre |e &sono chiamati operatori bit a bit . Servono a scopi diversi.

Gli operatori condizionali funzionano solo con espressioni che valutano staticamente boolean sia sul lato sinistro che sul lato destro.

Gli operatori bit a bit funzionano con qualsiasi operando numerico.

Se si desidera eseguire un confronto logico, è necessario utilizzare operatori condizionali , poiché si aggiungerà una sorta di sicurezza del tipo al codice.

Una nota a margine: Java ha | = ma non un || =

Un esempio di quando è necessario utilizzare || è quando la prima espressione è un test per vedere se la seconda espressione sarebbe esplosa. ad es. utilizzando un singolo | nel caso seguente potrebbe risultare in un NPE.

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

Le altre risposte hanno fatto un buon lavoro nel coprire la differenza funzionale tra gli operatori, ma le risposte potrebbero applicarsi a quasi ogni singolo linguaggio derivato dal C esistente oggi. La domanda è taggata conGiavae quindi cercherò di rispondere in modo specifico e tecnico per il linguaggio Java.

&e |possono essere operatori Bitwise interi o operatori logici booleani. La sintassi per gli operatori Bitwise e Logical ( §15.22 ) è:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

La sintassi per EqualityExpressionè definita in §15.21 , che richiede RelationalExpressiondefinito in §15.20 , che a sua volta richiede ShiftExpressione ReferenceTypedefinito in §15.19 e §4.3 , rispettivamente. ShiftExpressionrichiede AdditiveExpressiondefinito nel §15.18 , che continua a eseguire il drill down, definendo l'aritmetica di base, gli operatori unari, ecc. ReferenceTypeesegue il drill down in tutti i vari modi per rappresentare un tipo. (Sebbene ReferenceTypenon includa i tipi primitivi, alla fine è necessaria la definizione dei tipi primitivi, poiché potrebbero essere il tipo di dimensione per un array, che è unReferenceType .)

Gli operatori bit a bit e logici hanno le seguenti proprietà:

• Questi operatori hanno una precedenza diversa, con &la precedenza più alta e| la precedenza più bassa.
• Ognuno di questi operatori è sintatticamente associativo-sinistro (ogni gruppo da sinistra a destra).
• Ogni operatore è commutativo se le espressioni degli operandi non hanno effetti collaterali.
• Ogni operatore è associativo.
• Gli operatori bit per bit e logici possono essere usati per confrontare due operandi di tipo numerico o due operandi di tipo boolean. Tutti gli altri casi generano un errore in fase di compilazione.

La distinzione tra se l'operatore funge da operatore bit a bit o come operatore logico dipende dal fatto che gli operandi siano "convertibili in un tipo integrale primitivo" ( §4.2 ) o se siano di tipo booleano Boolean( §5.1.8 ).

Se gli operandi sono di tipo integrale, la promozione numerica binaria ( §5.6.2 ) viene eseguita su entrambi gli operandi, lasciandoli entrambi come longs o ints per l'operazione. Il tipo di operazione sarà il tipo di operandi (promossi). A quel punto, &sarà bit a bit AND, ^sarà bit a bit OR esclusivo e |sarà bit a bit OR inclusivo. ( §15.22.1 )

Se gli operandi sono booleano Boolean, gli operandi saranno soggetti a conversione unboxing, se necessario ( §5.1.8 ), e il tipo di operazione sarà boolean. &comporterà truese entrambi gli operandi lo saranno true, ^comporterà truese entrambi gli operandi sono diversi e |comporterà truese entrambi gli operandi lo sono true. ( §15.22.2 )

Al contrario, && è "Operatore condizionale" ( §15.23 ) ed ||è "Operatore condizionale" ( § 15.24 ). La loro sintassi è definita come:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&è come &, tranne per il fatto che valuta l'operando di destra solo se l'operando di sinistra è true. ||è come |, tranne per il fatto che valuta l'operando di destra solo se l'operando di sinistra èfalse .

Condizionale-E ha le seguenti proprietà:

• L'operatore condizionale e sintatticamente è associativo a sinistra (raggruppa da sinistra a destra).
• L'operatore condizionale e l'operatore sono pienamente associativi rispetto agli effetti collaterali e al valore del risultato. Cioè, per qualsiasi espressione a, be la cvalutazione dell'espressione ((a) && (b)) && (c)produce lo stesso risultato, con gli stessi effetti collaterali che si verificano nello stesso ordine, come la valutazione dell'espressione(a) && ((b) && (c)) .
• Ogni operando dell'operatore condizionale e deve essere di tipo booleanoBoolean , oppure si verifica un errore in fase di compilazione.
• Il tipo di un condizionale ed espressione è sempre boolean .
• In fase di esecuzione, l'espressione dell'operando di sinistra viene valutata per prima; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ).
• Se il valore risultante è false, il valore dell'espressione-condizionale è falsee l'espressione dell'operando di destra non viene valutata.
• Se il valore dell'operando di sinistra è true, viene valutata l'espressione di destra; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ). Il valore risultante diventa il valore dell'espressione-condizionale.
• Così, &&calcola lo stesso risultato &su booleanoperandi. Differisce solo dal fatto che l'espressione dell'operando della mano destra viene valutata in modo condizionale piuttosto che sempre.

Condizionale-O ha le seguenti proprietà:

• L'operatore condizionale o sintatticamente è associativo a sinistra (raggruppa da sinistra a destra).
• L'operatore condizionale o è completamente associativo rispetto agli effetti collaterali e al valore del risultato. Cioè, per qualsiasi espressione a, be c, la valutazione dell'espressione ((a) || (b)) || (c)produce lo stesso risultato, con gli stessi effetti collaterali che si verificano nello stesso ordine, come la valutazione dell'espressione (a) || ((b) || (c)).
• Ogni operando del condizionale o dell'operatore deve essere di tipo booleano Boolean, oppure si verifica un errore in fase di compilazione.
• Il tipo di un condizionale o espressione è sempre boolean .
• In fase di esecuzione, l'espressione dell'operando di sinistra viene valutata per prima; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ).
• Se il valore risultante è true, il valore dell'espressione condizionale o è truee l'espressione dell'operando di destra non viene valutata.
• Se il valore dell'operando di sinistra è false, viene valutata l'espressione di destra; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ). Il valore risultante diventa il valore del condizionale o dell'espressione.
• Pertanto, ||calcola lo stesso risultato di |on booleano Booleanoperandi. Differisce solo dal fatto che l'espressione dell'operando della mano destra viene valutata in modo condizionale piuttosto che sempre.

In breve, come ha sottolineato più volte @JohnMeagher nei commenti, &e |in realtà sono operatori booleani non in corto circuito nel caso specifico degli operandi che sono booleano Boolean. Con le buone pratiche (ovvero: nessun effetto secondario), questa è una differenza minore. Quando gli operandi non sono booleans o Booleans, tuttavia, gli operatori si comportano molto diversamente: bit a bit e operazioni logiche semplicemente non si confronta bene al livello di programmazione Java.

1). (Espressione1 | espressione2), | l'operatore valuterà expression2 indipendentemente dal fatto che il risultato di expression1 sia vero o falso.

Esempio:

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). (Espressione1 || espressione2), || l'operatore non valuterà expression2 se expression1 è true.

Esempio:

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

|| restituisce un valore booleano inserendo due valori (ecco perché è noto come LOGICO o)

IE:

if (A || B) 

Restituirà vero se A o B sono veri, o falso se sono entrambi falsi.

| è un operatore che esegue un'operazione bit a bit su due valori. Per comprendere meglio le operazioni bit per bit, puoi leggere qui:

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

Una delle differenze principali è che || e && mostrano "corto circuito", quindi l'RHS sarà valutato solo se necessario.

Per es

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

Sopra se a è vero, allora b non verrà testato e verrà eseguito path1. Se | è stato utilizzato quindi entrambe le parti sarebbero state valutate anche se 'a' è vero.

Vedi qui e qui , per qualche informazione in più.

Spero che questo ti aiuti.

Non corto circuito può essere utile. A volte vuoi assicurarti che due espressioni valutino. Ad esempio, supponiamo di avere un metodo che rimuove un oggetto da due elenchi separati. Potresti voler fare qualcosa del genere:

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

Se il metodo utilizzato invece utilizza l'operando condizionale, non rimuove l'oggetto dal secondo elenco se il primo elenco restituisce false.

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

Non è incredibilmente utile e (come con la maggior parte delle attività di programmazione) potresti raggiungerlo con altri mezzi. Ma è un caso d'uso per operandi bit a bit.

La differenza fondamentale tra loro è che | prima converte i valori in binario, quindi esegue il bit o l'operazione. Nel frattempo, || non converte i dati in binari ed esegue semplicemente l'espressione o sul suo stato originale.

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

Per saperne di più: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

Quando ho avuto questa domanda ho creato un codice di prova per farmi un'idea.

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

 }
}

In questo caso, cambiamo solo il valore del lato sinistro di if condition aggiungendo a o b.

|| Scenario, quando il lato sinistro è vero [if (a || bool ())]

produzione "If condition executed"

|| Scenario, quando il lato sinistro è falso [if (b || bool ())]

Produzione-

Bool
If condition executed

Conclusion of || Durante l'uso ||, il lato destro controlla solo quando il lato sinistro è falso.

| Scenario, quando il lato sinistro è vero [if (a | bool ())]

Produzione-

Bool
If condition executed

| Scenario, quando il lato sinistro è falso [if (b | bool ())]

Produzione-

Bool
If condition executed

Conclusion of | Durante l'uso |, controllare sia il lato sinistro che quello destro.

| = bit per bit o, || = logica o

di solito lo uso quando c'è un operatore pre-incremento e post-incremento. Guarda il seguente codice:

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

produzione:

stamperà per primo se
sono: 11

stamperà per secondo se
x è: 10

entrambi i ifblocchi sono uguali ma il risultato è diverso. quando c'è |, verranno valutate entrambe le condizioni. Ma se lo è ||, non valuterà la seconda condizione poiché la prima condizione è già vera.

Ci sono molti casi d'uso che suggeriscono perché dovresti cercare ||piuttosto che |. Alcuni casi d'uso devono usare| operatore per verificare tutte le condizioni.

Ad esempio, se si desidera verificare la convalida del modulo e si desidera mostrare all'utente tutti i campi non validi con testi di errore anziché solo un primo campo non valido.

|| operatore sarebbe,

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

Pertanto, con lo snippet precedente, se l'utente invia il modulo con TUTTI i campi vuoti, SOLO nameFieldverrà visualizzato con un messaggio di errore. Ma, se lo cambi in,

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

Mostrerà il messaggio di errore corretto su ciascun campo indipendentemente dalle truecondizioni.

Dopo aver letto attentamente questo argomento non mi è ancora chiaro se l'utilizzo |come operatore logico è conforme alle pratiche del modello Java.

Di recente ho modificato il codice in una richiesta pull indirizzando un commento in cui

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

doveva essere cambiato in

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

Qual è la versione effettivamente accettata?

La documentazione Java non viene menzionata |come operatore logico non in corto circuito.

Non sei interessato a un voto, ma piuttosto a scoprire lo standard ?! Entrambe le versioni del codice vengono compilate e funzionano come previsto.

|| è un logico o e | è un po 'saggio o.

Operatori Java

| è bit a bit o, || è logico o.

Date un'occhiata al:

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

| è bitally inclusivo OR

|| è OR logico

| è un operatore bit a bit. || è un operatore logico.

Uno prenderà due bit e / o loro.

Si determinerà la verità (questo OR quello) Se questo è vero o è vero, allora la risposta è vera.

Oh, e perché le persone rispondono a queste domande velocemente.