Pourquoi nous avons l'habitude d'utiliser `||` non `|`, quelle est la différence?

| ne pas le faire évaluation de court-circuit dans des expressions booléennes. || va s'arrêter à évaluer si le premier opérande est vrai, mais | ne sera pas.

En outre, | peut être utilisé pour effectuer l'opération de bits-OU de l'exploitation sur l'octet/court/int/long valeurs. || ne peut pas.

Logique || et && vérifier le côté droit seulement 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éécrire:

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éécrire:

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

En plus de court-circuit, d'une autre chose à garder à l'esprit est que de faire une opération logique bit à bit sur les valeurs, qui peut être autre que 0 ou 1 a une signification très différente de celle de la logique conditionnelle. Alors qu'il est GÉNÉRALEMENT le même pour | et ||, avec & et && vous obtenir des résultats très différents (par exemple, 2 & 4 est de 0/false, alors qu' 2 && 4 est de 1/vrai).

Si la chose que vous obtenez à partir d'une fonction est en fait un code d'erreur et vous faites des tests pour les non-0-ness, ce peut importe beaucoup.

Ce n'est pas un problème en Java où vous devez explicitement transtypage de booléens ou de comparer avec 0 ou similaire, mais dans d'autres langues avec la même syntaxe (C/C++ et al), il peut être assez déroutant.

Notez aussi que & et | peut s'appliquer uniquement de type entier des valeurs, et tout ce qui peut être équivalent à une valeur de type boolean test. Encore une fois, dans la non-Java langues, il y a un certain nombre de choses qui peut être utilisé comme un booléen avec un implicite != 0 comparaison (pointeurs, des flotteurs, des objets avec un operator bool(), etc.) et les opérateurs sur les bits sont presque toujours absurde dans ces contextes.

|| est l'opérateur logique ou tout | est l'opérateur de bits or.

boolean a = true;
boolean b = false;

if (a || b) {
}

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

Outre le fait que | est un bit à bit-opérateur: || est un court-circuit à l'opérateur lorsqu'un élément est faux, il ne vérifie pas les autres.

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

si quelque chose est VRAI, || ne sera pas évaluer someotherthing, tandis que | va faire. Si les variables de votre si-états sont en fait des appels de fonction, à l'aide de || est peut-être sauver une grande partie de la performance.

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.

Opérateurs conditionnels ne fonctionne qu'avec des expressions de manière statique évaluer à boolean à la fois à gauche et à droite.

Opérateurs au niveau du bit fonctionne avec un nombre d'opérandes.

Si vous souhaitez effectuer une comparaison logique, vous devez utiliser opérateurs conditionnels, car vous devrez ajouter un peu de type de type de sécurité de votre code.

Les autres réponses ont fait un bon travail de couverture de la différence fonctionnelle entre les opérateurs, mais les réponses pourraient s'appliquer à juste au sujet de chaque C dérivé de la langue en existence aujourd'hui. La question est taggés avec java, et donc je m'efforcerai de répondre précisément et techniquement pour le langage Java.

& et | peut être soit Entier Opérateurs au niveau du Bit, ou Booléens les Opérateurs Logiques. La syntaxe de l'or au niveau du Bit et d'Opérateurs Logiques (§15.22) est:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

La syntaxe pour EqualityExpression est défini dans §15.21, ce qui nécessite RelationalExpression défini dans §15.20, qui à son tour nécessite ShiftExpression et ReferenceType défini dans §15.19 et §4.3, respectivement. ShiftExpression nécessite AdditiveExpression défini dans §15.18, qui continue à descendre, la définition de l'arithmétique de base, les opérateurs unaires, etc. ReferenceType dissimulées dans toutes les différentes façons de représenter un type. (Alors que ReferenceType ne comprend pas les types primitifs, la définition de types primitifs est finalement nécessaire, car ils peuvent être le type de dimension pour un tableau, qui est un ReferenceType.)

Les Opérateurs Logiques bit à Bit et ont les propriétés suivantes:

• Ces opérateurs ont différentes priorité, avec & ayant la priorité la plus élevée et | la priorité la plus basse.
• Chacun de ces opérateurs est syntaxiquement associatifs gauche (chaque groupes de gauche à droite).
• Chaque opérateur est commutative si l'opérande expressions ont pas d'effets secondaires.
• Chaque opérateur est associative.
• Les opérateurs logiques bit à bit et peut être utilisé pour comparer deux opérandes de type numérique ou deux opérandes de type boolean. Tous les autres cas, entraîner une erreur de compilation.

La distinction entre l'opérateur sert un bit à bit opérateur ou un opérateur logique dépend si les opérandes sont convertibles à une primitive de type intégral" (§4.2) ou si elles sont de types boolean ou Boolean (§5.1.8).

Si les opérandes sont les types intégraux, binaire numérique de promotion (§5.6.2) est effectuée sur les deux opérandes, les laissant à la fois comme longs ou ints pour l'opération. Le type de l'opération sera le type de la (promu) opérandes. À ce point, & sera au niveau du bit ET, ^ seront bit à bit OU exclusif, et | sera inclusif bit à bit OU. (§15.22.1)

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

En revanche, && est le "Conditionnel Et de l'Opérateur" (§15.23) et || est le "Conditionnel Ou de l'Exploitant" (§15.24). Leur syntaxe est définie comme:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&& est comme &, sauf qu'il n'évalue l'opérande de droite si l'opérande de gauche est true. || est comme |, sauf qu'il n'évalue l'opérande de droite si l'opérande de gauche est false.

Conditionnel Et a les propriétés suivantes:

• Le conditionnel et l'opérateur est syntaxiquement associatifs gauche (c'groupes de gauche à droite).
• Le conditionnel et l'opérateur est entièrement associatif à l'égard à la fois des effets secondaires et la valeur du résultat. C'est, pour toutes les expressions a, b, et c, l'évaluation de l'expression ((a) && (b)) && (c) produit le même résultat, avec les mêmes effets secondaires survenant dans le même ordre, à l'évaluation de l'expression (a) && ((b) && (c)).
• Chaque opérande de le conditionnel et l'opérateur doit être de type boolean ou Boolean, ou une erreur de compilation se produit.
• Le type de conditionnel et de l'expression est toujours boolean.
• Au moment de l'exécution, la gauche opérande expression est évaluée en premier; si le résultat est de type Boolean, il est soumis à un unboxing de conversion (§5.1.8).
• Si la valeur obtenue est false, la valeur du conditionnel-et l'expression est false et celui de droite les opérandes de l'expression n'est pas évaluée.
• Si la valeur de gauche opérande est true, puis la partie droite de l'expression est évaluée; si le résultat est de type Boolean, il est soumis à un unboxing de conversion (§5.1.8). La valeur qui en résulte devient la valeur de conditionnel et de l'expression.
• Ainsi, && calcule le même résultat que & sur boolean opérandes. Il ne diffère en ce que la partie droite de l'opérande expression est évaluée de façon conditionnelle plutôt que de toujours.

Conditionnel Ou a les propriétés suivantes:

• Le conditionnel ou l'exploitant est syntaxiquement associatifs gauche (c'groupes de gauche à droite).
• Le conditionnel ou l'exploitant est totalement associatif à l'égard à la fois des effets secondaires et la valeur du résultat. C'est, pour toutes les expressions a, b, et c, l'évaluation de l'expression ((a) || (b)) || (c) produit le même résultat, avec les mêmes effets secondaires survenant dans le même ordre, à l'évaluation de l'expression (a) || ((b) || (c)).
• Chaque opérande du conditionnel ou de l'exploitant doit être de type boolean ou Boolean, ou une erreur de compilation se produit.
• Le type d'un conditionnel ou l'expression est toujours boolean.
• Au moment de l'exécution, la gauche opérande expression est évaluée en premier; si le résultat est de type Boolean, il est soumis à un unboxing de conversion (§5.1.8).
• Si la valeur obtenue est true, la valeur du conditionnel ou de l'expression est true et celui de droite les opérandes de l'expression n'est pas évaluée.
• Si la valeur de gauche opérande est false, puis la partie droite de l'expression est évaluée; si le résultat est de type Boolean, il est soumis à un unboxing de conversion (§5.1.8). La valeur qui en résulte devient la valeur du conditionnel ou de l'expression.
• Ainsi, || calcule le même résultat que | sur boolean ou Boolean opérandes. Il ne diffère en ce que la partie droite de l'opérande expression est évaluée de façon conditionnelle plutôt que de toujours.

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

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

IE:

if (A || B) 

Serait de retourner vrai si A ou B est vrai, ou faux si ils sont tous les deux faux.

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

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

Non court-circuit accidentel peut être utile. Parfois, vous voulez vous assurer que les deux expressions sont évaluées. Par exemple, disons que vous avez une méthode qui supprime un objet à partir de deux listes distinctes. Vous voulez 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 plutôt utilisé le conditionnel opérande, il ne parviendrait pas à retirer l'objet à partir de la deuxième liste, si la première liste retourné false.

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

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

Lorsque j'ai eu cette question, j'ai créé un code de test pour se faire 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 ne du changement côté gauche de la valeur de si la condition de l'ajout d'un ou de b.

|| Scénario , lors de la gauche vrai [si(a||bool())]

sortie "If condition executed"

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

De sortie-

Bool
If condition executed

Conclusion of || Lors de l'utilisation ||, du côté droit uniquement à vérifier lorsque la gauche est faux.

| Scénario , lors de la gauche vrai [si(a|bool())]

De sortie-

Bool
If condition executed

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

De sortie-

Bool
If condition executed

Conclusion of | Lors de l'utilisation |, vérifier à la fois de droite et de gauche.

habituellement j'utilise quand il est pré incrémentation et post opérateur d'incrémentation. 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);
    }
    }
}

de sortie:

il permet d'imprimer en premier si

i est: 11

il permet d'imprimer en deuxième si

x est: 10

les deux if blocs sont les mêmes, mais le résultat est différent.
quand il y a |, à la fois les conditions seront évaluées. Mais si c'est ||, il ne sera pas évaluer seconde condition que la première condition est déjà le cas.

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

Prendre un coup d'oeil à:

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

| est inclusif bit à bit OU

|| est logique OU