Dans cette section, nous aborderons les deux opérateurs les plus importants & et && dans Java et voir aussi le principales différences entre logique et opérateurs au niveau du bit ainsi que ses utilisations.
& Opérateur
L'opérateur ET unique ( & ) est connu sous le nom de ET au niveau du bit opérateur. Il fonctionne sur un seul bit. Cela prend deux opérandes. Un bit du résultat est 1 si et seulement si les deux bits correspondants dans les opérandes sont 1. Le résultat de l'opérateur peut être n'importe quel nombre. Par exemple:
a = 01100010
b = 10111010
a&b = 00100010
&& Opérateur
Les opérateurs double ET (&&) sont appelés ET logique les opérateurs. Il est généralement utilisé dans les boucles et les instructions conditionnelles. Il est généralement utilisé dans les expressions booléennes. Le résultat de && est toujours 0 ou 1.
Différence entre & et &&
La principale différence entre les opérateurs && et & est que && prend en charge les évaluations de court-circuit alors que l'opérateur & ne le fait pas.
Une autre différence est que && évaluera l'expression exp1 et renverra immédiatement une valeur fausse si exp1 est fausse. L'opérateur While & évalue toujours les deux expressions (exp1 et exp2) avant de retirer une réponse.
| S.N. | Base | & Opérateur | && Opérateur |
|---|---|---|---|
| 1 | Opérateur | Il s'agit d'un opérateur ET au niveau du bit. | C'est un opérateur ET logique. |
| 2 | Évaluation | Il évalue à la fois les côtés gauche et droit de l'expression donnée. | Il évalue uniquement les côtés gauches de l'expression donnée. |
| 3 | Fonctionne sur | Il fonctionne sur les types de données booléens ainsi que sur les bits. | Il fonctionne uniquement sur le type de données booléen. |
| 4 | Les usages | Utilisé pour vérifier la condition logique et également utilisé pour masquer certains bits tels que les bits de parité. | Utilisé uniquement pour vérifier les conditions logiques. |
| 5 | Exemple | z = x et y | si (y > 1 && y > x) |
Comprenons le bit à bit, la logique et l'opérateur via un programme Java.
LogicalAndExample.java
tranche de tableau Java
public class LogicalAndExample { public static void main(String args[]) { int a=10, b=20; if (a == 10 && b == 20) System.out.println('true'); else System.out.println('false'); int c=78, d=90; if (a > c && b <d) system.out.println('true'); else system.out.println('false'); } < pre> <p> <strong>Output:</strong> </p> <pre> true false </pre> <p> <strong>BitwiseAndExample.java</strong> </p> <pre> public class BitwiseAndExample { public static void main(String args[]) { int a = 3; int b = 9; //bitwise AND System.out.println('a&b = ' + (a & b)); } } </pre> <p> <strong>Output:</strong> </p> <pre> a&b=1 </pre> <p>Let's create another Java program and use Logical and Bitwise AND operators simultaneously.</p> <p> <strong>JavaOperators.java</strong> </p> <pre> public class JavaOperators { public static void main(String args[]) { int a = 58; //58 in binary is 111010 int b = 13; //13 in binary is 1101 System.out.println(a&b); //returns 8 = 1000 int x = 10; System.out.println(x<30 && x<60); returns false } < pre> <p> <strong>Output:</strong> </p> <pre> 8 true </pre> <hr></30></pre></d)> BitwiseAndExample.java
public class BitwiseAndExample { public static void main(String args[]) { int a = 3; int b = 9; //bitwise AND System.out.println('a&b = ' + (a & b)); } } Sortir:
a&b=1
Créons un autre programme Java et utilisons simultanément les opérateurs AND logiques et au niveau du bit.
JavaOperators.java
public class JavaOperators { public static void main(String args[]) { int a = 58; //58 in binary is 111010 int b = 13; //13 in binary is 1101 System.out.println(a&b); //returns 8 = 1000 int x = 10; System.out.println(x<30 && x<60); returns false } < pre> <p> <strong>Output:</strong> </p> <pre> 8 true </pre> <hr></30>