[java] Perché di solito usiamo `||` non `|`, qual è la differenza?



Answers

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

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

Question

Mi sto solo chiedendo perché usiamo normalmente OR || tra due booleani non a bit OR | , anche se stanno entrambi lavorando 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 && .




di solito utilizzo quando c'è un operatore di 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à prima se
Io sono: 11

stamperà in secondi se
x è: 10

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




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

boolean a = true;
boolean b = false;

if (a || b) {
}

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



a | b: valutare b in ogni caso

a || b: valuta b solo se si valuta su falso




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 il valore 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à un tipo di protezione del codice al proprio codice.




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



Il non cortocircuito può essere utile. A volte vuoi essere sicuro che valuti due espressioni. 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 tuo metodo invece utilizzava l'operando condizionale, non riusciva a rimuovere l'oggetto dal secondo elenco se il primo elenco restituiva false.

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

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




Logico || e && controlla il lato destro solo se necessario. Il | e controlla sempre tutto il tempo.

Per esempio:

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

Riscrivialo:

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i doesn't = 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
...

Riscrivialo:

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



Oltre al cortocircuito, un'altra cosa da tenere a mente è che l'operazione logica bit a bit su valori che possono essere diversi da 0 o 1 ha un significato molto diverso dalla logica condizionale. Mentre USUALMENTE è lo stesso per | e || , con & e && ottieni risultati molto diversi (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 provando per non-0-ness, questo può essere un problema.

Questo non è tanto un problema in Java in cui è necessario tipografarlo esplicitamente in booleano o confrontare con 0 o simili, ma in altri linguaggi con sintassi simile (C / C ++ et al) può essere abbastanza confuso.

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




La differenza fondamentale tra loro è quella | prima converte i valori in binario, quindi esegue il bit saggio o l'operazione. Nel frattempo, || non converte i dati in binari e semplicemente esegue l'espressione o al 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




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

IE:

if (A || B) 

Restituisce vero se A o B è vero o falso se entrambi sono falsi.

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

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







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

Uno prenderà due bit e o loro.

Uno determinerà la verità (questa O quella) Se questo è vero o è vero, allora la risposta è vera.

Oh, e le persone pericolose rispondono velocemente a queste domande.






Related