Pourquoi utilisons-nous habituellement || plus |? Quelle est la différence?

Je me demande simplement pourquoi nous utilisons habituellement un OU logique || entre deux booléens qui ne sont pas des bits OU |, bien qu'ils fonctionnent tous les deux bien.

Je veux dire, regardez ce qui suit:

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

Pouvons-nous utiliser à la |place de ||? Même chose avec &et &&.

Si vous utilisez les formulaires ||et &&, plutôt que les formulaires |et &de ces opérateurs, Java ne prendra pas la peine d'évaluer seul l'opérande de droite.

Il s'agit de savoir si vous voulez court-circuiter l'évaluation ou non - la plupart du temps vous le souhaitez.

Un bon moyen d'illustrer les avantages du court-circuit serait de considérer l'exemple suivant.

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

Un autre avantage, comme Jeremy et Peter l'ont mentionné, pour le court-circuit est la vérification de référence nulle:

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

Plus d'informations

| ne fait pas d' évaluation de court-circuit dans les expressions booléennes. ||arrêtera d'évaluer si le premier opérande est vrai, mais| ne le sera pas.

De plus, |peut être utilisé pour effectuer l'opération OR au niveau du bit sur des valeurs d'octet / court / int / long. ||ne peux pas.

Donc, juste pour construire sur les autres réponses avec un exemple, le court-circuit est crucial dans les contrôles défensifs suivants:

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

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

À la place, l' utilisation de |et &pourrait entraîner un NullPointerExceptionjet ici.

Logique ||et &&vérifiez le côté droit uniquement si nécessaire. Le |et& vérifier à la fois les côtés à chaque fois .

Par exemple:

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

Réécrivez-le:

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

Un autre exemple:

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

Réécrivez-le:

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

Notez également un écueil commun: les opérateurs non paresseux ont priorité sur les paresseux, donc:

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

Soyez prudent lorsque vous les mélangez.

En plus du court-circuit, une autre chose à garder à l'esprit est que faire une opération logique au niveau du bit sur des valeurs qui peuvent être différentes de 0 ou 1 a une signification très différente de la logique conditionnelle. Bien que ce soit généralement le même pour |et ||, avec &et &&vous obtenez des résultats très différents (par exemple, 2 & 4est 0 / faux pendant2 && 4 est 1 / vrai).

Si la chose que vous obtenez d'une fonction est en fait un code d'erreur et que vous testez la non-0-ness, cela peut avoir beaucoup d'importance.

Ce n'est pas autant un problème en Java où vous devez explicitement transtyper en booléen ou comparer avec 0 ou similaire, mais dans d'autres langages avec une syntaxe similaire (C / C ++ et al), cela peut être assez déroutant.

Notez également que & et | ne peut s'appliquer qu'aux valeurs de type entier et non à tout ce qui peut être équivalent à un test booléen. Encore une fois, dans les langages non Java, il y a pas mal de choses qui peuvent être utilisées comme un booléen avec une != 0comparaison implicite (pointeurs, flottants, objets avec un operator bool(), etc.) et les opérateurs au niveau du bit sont presque toujours absurdes dans ces contextes.

La seule fois où vous utiliseriez |ou à la &place de ||ou &&c'est lorsque vous avez des expressions booléennes très simples et que le coût d'un raccourci (c'est-à-dire une branche) est supérieur au temps que vous économisez en n'évaluant pas les expressions les plus récentes.

Cependant, il s'agit d'une micro-optimisation qui compte rarement sauf dans le code le plus bas.

|| est l'opérateur logique ou tandis que | est l'opérateur au niveau du bit ou.

boolean a = true;
boolean b = false;

if (a || b) {
}

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

a | b: évaluer b dans tous les cas

a || b: évalue b uniquement si a est évalué à faux

En plus du fait que | est un opérateur au niveau du bit: || est un opérateur de court-circuit - lorsqu'un élément est faux, il ne vérifie pas les autres.

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

si quelque chose est VRAI, || n'évaluera pas autre chose, alors que | ça ira. Si les variables de vos instructions if sont en fait des appels de fonction, utilisez || économise peut-être beaucoup de performances.

| is the binary or operator

|| is the logic or operator

Les opérateurs ||et &&sont appelés opérateurs conditionnels , tandis que| et &sont appelés opérateurs au niveau du bit . Ils servent à des fins différentes.

Les opérateurs conditionnels ne fonctionnent qu'avec des expressions qui sont évaluées statiquement à booleangauche et à droite.

Les opérateurs au niveau du bit fonctionnent avec tous les opérandes numériques.

Si vous souhaitez effectuer une comparaison logique, vous devez utiliser des opérateurs conditionnels , car vous ajouterez une sorte de sécurité de type à votre code.

Une note latérale: Java a | = mais pas un || =

Un exemple de quand vous devez utiliser || c'est quand la première expression est un test pour voir si la deuxième expression exploserait. par exemple en utilisant un seul | dans le cas suivant, il pourrait en résulter un NPE.

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

Les autres réponses ont fait un bon travail pour couvrir la différence fonctionnelle entre les opérateurs, mais les réponses pourraient s'appliquer à à peu près tous les langages dérivés de C existants aujourd'hui. La question est étiquetée avecJava, et donc je m'efforcerai de répondre spécifiquement et techniquement au langage Java.

&et |peut être soit des opérateurs binaires entiers, soit des opérateurs logiques booléens. La syntaxe des opérateurs binaires et logiques ( §15.22 ) est:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

La syntaxe de EqualityExpressionest définie au § 15.21 , qui nécessite d'être RelationalExpressiondéfinie au § 15.20 , qui à son tour requiert ShiftExpressionet ReferenceTypedéfinie au § 15.19 et au § 4.3 , respectivement. ShiftExpressionrequiert AdditiveExpressiondéfini au §15.18 , qui continue à explorer, en définissant l'arithmétique de base, les opérateurs unaires, etc. ReferenceTypeexplore toutes les différentes façons de représenter un type. (Bien qu'il ReferenceTypen'inclue pas les types primitifs, la définition des types primitifs est finalement requise, car ils peuvent être le type de dimension pour un tableau, qui est a ReferenceType.)

Les opérateurs binaires et logiques ont les propriétés suivantes:

• Ces opérateurs ont une priorité différente, avec &la priorité la plus élevée et| la plus la priorité la plus faible.
• Chacun de ces opérateurs est syntaxiquement associatif à gauche (chaque groupe de gauche à droite).
• Chaque opérateur est commutatif si les expressions d'opérande n'ont pas d'effets secondaires.
• Chaque opérateur est associatif.
• Les opérateurs binaires et logiques peuvent être utilisés pour comparer deux opérandes de type numérique ou deux opérandes de type boolean. Tous les autres cas entraînent une erreur de compilation.

La distinction entre si l'opérateur sert d'opérateur au niveau du bit ou d'opérateur logique dépend du fait que les opérandes sont "convertibles en un type intégral primitif" ( §4.2 ) ou s'ils sont de types booleanou Boolean( §5.1.8 ).

Si les opérandes sont de type intégral, une promotion numérique binaire ( §5.6.2 ) est effectuée sur les deux opérandes, en les laissant tous les deux comme longs ou ints pour l'opération. Le type de l'opération sera le type des opérandes (promus). À ce stade, &sera ET au niveau du bit, ^sera OU exclusif au niveau du bit et |sera OU inclus au niveau du bit. ( §15.22.1 )

Si les opérandes sont booleanou Boolean, les opérandes seront soumis à une conversion de déballage si nécessaire ( §5.1.8 ), et le type de l'opération sera boolean. &entraînera truesi les deux opérandes le sont true, ^entraînera truesi les deux opérandes sont différents et |entraînera truesi l'un des opérandes l'est true. ( §15.22.2 )

En revanche, && est le "Conditional-And Operator" ( §15.23 ) et ||est le "Conditional-Or Operator" ( §15.24 ). Leur syntaxe est définie comme:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&est similaire &, sauf qu'il n'évalue l'opérande droit que si l'opérande gauche l'est true. ||est similaire |, sauf qu'il n'évalue l'opérande droit que si l'opérande gauche l'est false.

Conditionnel-Et a les propriétés suivantes:

• L'opérateur conditionnel et est syntaxiquement associatif à gauche (il regroupe de gauche à droite).
• L'opérateur conditionnel et est entièrement associatif en ce qui concerne à la fois les effets secondaires et la valeur du résultat. C'est, pour toutes les expressions a, bet c, l' évaluation de l'expression ((a) && (b)) && (c)produit le même résultat, avec les mêmes effets secondaires se produisant dans le même ordre, que l' évaluation de l'expression (a) && ((b) && (c)).
• Chaque opérande de l'opérateur conditionnel et doit être de type booleanou Boolean, sinon une erreur de compilation se produit.
• Le type d'une expression conditionnelle et est toujours boolean.
• Au moment de l'exécution, l'expression d'opérande de gauche est évaluée en premier; si le résultat est de type Boolean, il est soumis à une conversion de déballage ( §5.1.8 ).
• Si la valeur résultante est false, la valeur de l'expression conditionnelle et est falseet l'expression d'opérande de droite n'est pas évaluée.
• Si la valeur de l'opérande de gauche est true, alors l'expression de droite est évaluée; si le résultat est de type Boolean, il est soumis à une conversion de déballage ( §5.1.8 ). La valeur résultante devient la valeur de l'expression conditionnelle et.
• Ainsi, &&calcule le même résultat que &sur les booleanopérandes. Elle ne diffère que par le fait que l'expression d'opérande de droite est évaluée de manière conditionnelle plutôt que toujours.

Conditional-Or a les propriétés suivantes:

• L'opérateur conditionnel ou est syntaxiquement associatif à gauche (il regroupe de gauche à droite).
• L'opérateur conditionnel ou est entièrement associatif en ce qui concerne à la fois les effets secondaires et la valeur du résultat. C'est, pour toutes les expressions a, bet c, l' évaluation de l'expression ((a) || (b)) || (c)produit le même résultat, avec les mêmes effets secondaires se produisant dans le même ordre, que l' évaluation de l'expression (a) || ((b) || (c)).
• Chaque opérande de l'opérateur conditionnel ou doit être de type booleanouBoolean , sinon une erreur de compilation se produit.
• Le type d'une expression conditionnelle ou est toujours boolean.
• Au moment de l'exécution, l'expression d'opérande de gauche est évaluée en premier; si le résultat est de type Boolean, il est soumis à une conversion de déballage ( §5.1.8 ).
• Si la valeur résultante est true, la valeur de l'expression conditionnelle ou est trueet l'expression d'opérande de droite n'est pas évaluée.
• Si la valeur de l'opérande de gauche est false, alors l'expression de droite est évaluée; si le résultat est de type Boolean, il est soumis à une conversion de déballage ( §5.1.8 ). La valeur résultante devient la valeur de l'expression conditionnelle ou.
• Ainsi, ||calcule le même résultat que |sur booleanou Booleanopérandes. Elle ne diffère que par le fait que l'expression d'opérande de droite est évaluée de manière conditionnelle plutôt que toujours.

En bref, comme @JohnMeagher l'a souligné à plusieurs reprises dans les commentaires, &et |sont en fait des opérateurs booléens ne court-circuitant pas dans le cas spécifique des opérandes étant soit booleanou Boolean. Avec les bonnes pratiques (ie: pas d'effets secondaires), c'est une différence mineure. Cependant, lorsque les opérandes ne sont pas booleans ou Booleans, les opérateurs se comportent très différemment: les opérations au niveau du bit et logiques ne se comparent tout simplement pas bien au niveau élevé de la programmation Java.

1). (Expression1 | expression2), | L'opérateur évaluera expression2, que le résultat de expression1 soit vrai ou faux.

Exemple:

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). (Expression1 || expression2), || L'opérateur n'évaluera pas expression2 si expression1 est vraie.

Exemple:

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

|| renvoie une valeur booléenne en OU deux valeurs (c'est pourquoi son connu comme un LOGIQUE ou)

C'EST À DIRE:

if (A || B) 

Renvoie vrai si A ou B est vrai, ou faux si les deux sont faux.

| est un opérateur qui effectue une opération au niveau du bit sur deux valeurs. Pour mieux comprendre les opérations au niveau du bit, vous pouvez lire ici:

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

Une différence principale est que || et && présentent un "court-circuit", donc le RHS ne sera évalué que si nécessaire.

Par exemple

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

Au-dessus, si a est vrai, b ne sera pas testé et path1 sera exécuté. Si | a été utilisé, les deux côtés seraient évalués même si «a» est vrai.

Voir ici et ici , pour un peu plus d'informations.

J'espère que cela t'aides.

La non mise en court-circuit peut être utile. Parfois, vous voulez vous assurer que deux expressions sont évaluées. Par exemple, supposons que vous ayez une méthode qui supprime un objet de deux listes distinctes. Vous voudrez peut-être faire quelque chose comme ceci:

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

Si votre méthode utilisait à la place l'opérande conditionnelle, elle ne parviendrait pas à supprimer l'objet de la deuxième liste si la première liste renvoyait false.

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

Ce n'est pas incroyablement utile, et (comme pour la plupart des tâches de programmation), vous pouvez le réaliser avec d'autres moyens. Mais c'est un cas d'utilisation pour les opérandes au niveau du bit.

La différence fondamentale entre eux est que | convertit d'abord les valeurs en binaire puis effectue l'opération ou le bit. Pendant ce temps, || ne convertit pas les données en binaire et exécute simplement l'expression or sur son état d'origine.

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

En savoir plus: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

Quand j'ai eu cette question, j'ai créé un code de test pour avoir une idée à ce sujet.

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

 }
}

Dans ce cas, nous modifions uniquement la valeur de gauche de if si la condition ajoute a ou b.

|| Scénario, lorsque le côté gauche est vrai [if (a || bool ())]

production "If condition executed"

|| Scénario, lorsque le côté gauche est faux [if (b || bool ())]

Production-

Bool
If condition executed

Conclusion of || Lors de l'utilisation ||, le côté droit ne vérifie que lorsque le côté gauche est faux.

| Scénario, lorsque le côté gauche est vrai [if (a | bool ())]

Production-

Bool
If condition executed

| Scénario, lorsque le côté gauche est faux [if (b | bool ())]

Production-

Bool
If condition executed

Conclusion of | Lors de l'utilisation |, vérifiez les côtés gauche et droit.

| = au niveau du bit ou, || = logique ou

habituellement j'utilise quand il y a un opérateur pré-incrément et post-incrément. Regardez le code suivant:

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

production:

il imprimera en premier si
i est: 11

il imprimera en deuxième si
x est: 10

les deux ifblocs sont identiques mais le résultat est différent. quand il y en a |, les deux conditions seront évaluées. Mais si c'est le cas ||, il n'évaluera pas la deuxième condition car la première condition est déjà vraie.

Il existe de nombreux cas d'utilisation suggérant pourquoi vous devriez y aller ||plutôt que |. Certains cas d' utilisation doivent utiliser| opérateur pour vérifier toutes les conditions.

Par exemple, si vous souhaitez vérifier la validation du formulaire et que vous souhaitez montrer à l'utilisateur tous les champs non valides avec des textes d'erreur plutôt qu'un seul premier champ non valide.

|| l'opérateur serait,

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

Ainsi, avec l'extrait ci-dessus, si l'utilisateur soumet le formulaire avec TOUS les champs vides, SEUL nameFieldsera affiché avec un message d'erreur. Mais si vous le changez en,

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

Il affichera un message d'erreur approprié sur chaque champ, quelles que soient les trueconditions.

Après avoir lu attentivement ce sujet, je ne sais toujours pas si vous utilisez | tant qu'opérateur logique est conforme aux pratiques de modèle Java.

J'ai récemment modifié le code dans une demande de tirage adressant un commentaire où

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

a dû être changé pour

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

Quelle est la version réellement acceptée?

La documentation Java n'est pas mentionnée |comme un opérateur OR logique sans court-circuit.

Pas intéressé par un vote mais plutôt par la recherche de la norme?! Les deux versions de code se compilent et fonctionnent comme prévu.

|| est un ou logique et | est un peu sage ou.

Opérateurs Java

| est au niveau du bit ou, || est logique ou.

Jeter un coup d'œil à:

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

| est inclus au niveau du bit OU

|| est logique OU

| est un opérateur au niveau du bit. || est un opérateur logique.

On prendra deux bits et / ou eux.

On déterminera la vérité (ceci OU cela) Si c'est vrai ou cela est vrai, alors la réponse est vraie.

Oh, et les gens dang répondent rapidement à ces questions.