Y a-t-il une différence entre utiliser un opérateur logique ou un opérateur bitwise dans un bloc if en Java?

Le contenu des deux éléments suivants si les blocs doivent être exécutées:

if( booleanFunction() || otherBooleanFunction() ) {...}
if( booleanFunction() | otherBooleanFunction() ) {...}

Alors, quelle est la différence entre l'utilisation de | ou à l'aide de ||?

Remarque: j'ai regardé et trouvé ma réponse, que j'ai inclus ci-dessous. N'hésitez pas à me corriger ou à donner votre point de vue. Il est sûr de place à l'amélioration!

source d'informationauteur Miquel

  1. 34

    Les deux usages différents. Bien que dans de nombreux cas (lorsque vous traitez avec des booléens), il peut apparaître qu'ils ont le même effet, il est important de noter que la logique OU est le court-circuit, ce qui signifie que si son premier argument est true, alors le second argument est de gauche non évaluée. L'opérateur au niveau du bit évalue à la fois de ses arguments, peu importe.

    De même, la logique ET est en court-circuit, ce qui signifie que si son premier argument est évaluée à false, alors que la seconde est à gauche non évaluée. Encore une fois, le bit-à-bit-ET ne l'est pas.

    Vous pouvez le voir en action ici:

    int x = 0;
int y = 1;
System.out.println(x+y == 1 || y/x == 1);
System.out.println(x+y == 1 |  y/x == 1);

    La première instruction d'impression fonctionne très bien et renvoie vrai depuis le premier argument a la valeur true, et donc l'évaluation s'arrête. La deuxième impression de la déclaration des erreurs, car il n'est pas court-circuit, et une division par zéro est rencontré.

  2. 12

    L'opérateur logique fonctionne sur les booléens, et le bit à bit de l'opérateur travaille sur les bits. Dans ce cas, l'effet est le même, mais il y a deux différences:

    1. L'opérateur au niveau du bit n'est pas fait pour ça, ce qui le rend plus difficile à lire, mais plus important encore
    2. La logique OU l'opérateur de l'évaluation de la première condition. Si c'est vrai, il n'a pas d'importance ce que le prochain état des résultats, du résultat sera vrai, donc la deuxième clause de non-exécution

    Voici un peu de pratique code pour le prouver:

    public class OperatorTest {

    public static void main(String[] args){
        System.out.println("Logical Operator:");
        if(sayAndReturn(true, "first") || sayAndReturn(true, "second")){
            //doNothing
        }

        System.out.println("Bitwise Operator:");
        if(sayAndReturn(true, "first") | sayAndReturn(true, "second")){
            //doNothing
        }
    }

    public static boolean sayAndReturn(boolean ret, String msg){
        System.out.println(msg);
        return ret;
    }
}
  3. 6

    pour les programmeurs, il y a seulement une différence.

    1. votre logiques les opérateurs logiques,c'est à dire tester une seule condition, et obtenez le résultat sur cette base.

    booleanFunction() || otherBooleanFunction() sera vrai si l'une est vraie. de même, booleanFunction() && otherBooleanFunction() sera fausse si l'un des deux est faux. Alors, pourquoi le test de l'autre. c'est ce que les opérateurs logiques ne.

    Mais au niveau du bit celles vérifier à la fois. Une application fréquente de ce concept est comme suit.

    if(someObject != null && someObject.somemethod())

    Donc, dans ce cas, si vous remplacez && par & puis attendre une catastrophe. Vous obtiendrez méchant NullPointerException bientôt...

  4. 4
    if( booleanFunction() || otherBooleanFunction() ) {...}

    Dans cette condition si booleanFunction() retourne true puis otherBooleanFunction() ne seraient pas exécutés.

    if( booleanFunction() | otherBooleanFunction() ) {...}

    Mais dans l'opérateur au niveau du bit à la fois des fonctions - booleanFunction() et otherBooleanFunction() serait exécuté n'importe booleanFunction() retourne true ou false

  5. 0

    Différence entre bit-à-bit d un opérateur logique-
    1. Au niveau du bit opérateur travaille sur bits alors que les logiques de l'opérateur travaille sur la déclaration.
    2. Au niveau du bit et est représenté par & considérant que logique et est représenté par &&.
    3. Or au niveau du bit est représenté par | alors que le ou logique est représenté par ||.