Introduction aux opérateurs booléens en Java
Avec l'avènement de la technologie, les ordinateurs se sont développés, ce qui a entraîné la nécessité d'un langage de programmation. Il existe de nombreux langages de programmation qui incluent à la fois un langage de bas niveau et un langage de haut niveau. Les langues de haut niveau sont plus faciles à utiliser car elles sont faciles à comprendre par rapport aux langues de bas niveau. Java est l'un de ces langages de haut niveau qui est largement utilisé comme langage de sauvegarde à des fins de programmation. Il y a beaucoup de concept que l'on doit étudier et pratiquer pour comprendre les concepts de base. Dans cette rubrique, nous discuterons des opérateurs booléens en Java.
Qu'est-ce que l'opérateur booléen?
Les opérateurs booléens sont simplement un ensemble d'opérateurs différents qui pourraient être utilisés pour comparer des expressions. Les opérateurs booléens ont généralement deux valeurs fausses ou vraies. Les opérateurs booléens comparent l'expression du côté gauche et du côté droit. En comparaison, il renvoie simplement une valeur booléenne
Types d'opérateurs booléens en Java
Il existe différents types d'opérateurs booléens en Java. Voici les différents types d'opérateurs booléens en Java les plus utilisés
- ET logique
- OU logique
- Égal à
- Pas égal à
- Opérateur ternaire
1) Opérateur logique ET
Il s'agit d'une affectation logique qui utilise l'opérateur && pour comparer l'expression logique. Il donne généralement faux si l'une des multiples logiques échoue ou donne vrai si toute l'expression produit vrai
Exemple d'opérateur ET -
- Si les deux opérandes sont vrais, le résultat de l'opération est vrai
public class Main
(
public static void main(String() args) (
boolean a = true;
boolean b = true;
System.out.println (a && b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : vrai
- Si les deux opérandes sont faux, le résultat de l'opération est faux
public class Main
(
public static void main(String() args) (
boolean a = false;
boolean b = false;
System.out.println (a && b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : faux
- Si un opérande est vrai et que l'autre est faux, le résultat de l'opération est faux
public class Main
(
public static void main(String() args) (
boolean a = true;
boolean b = false;
System.out.println (a && b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : faux
- Si un opérande est faux et que l'autre est vrai, le résultat de l'opération est faux
public class Main
(
public static void main(String() args) (
boolean a = false;
boolean b = true;
System.out.println (a && b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : faux
2) Opérateur logique OU
Il s'agit d'une affectation logique qui utilise || pour comparer l'expression logique. Il donne généralement la valeur true si l'une des expressions devient vraie et renvoie false si toute l'expression échoue.
Exemple d'opérateur OR -
- Si les deux opérandes sont vrais, le résultat de l'opération est vrai
public class Main
(
public static void main(String() args) (
boolean a = true;
boolean b = true;
System.out.println (a || b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : vrai
- Si les deux opérandes sont faux, le résultat de l'opération est faux
public class Main
(
public static void main(String() args) (
boolean a = false;
boolean b = false;
System.out.println (a || b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : faux
- Si un opérande est vrai et l'autre faux, le résultat de l'opération est vrai
public class Main
(
public static void main(String() args) (
boolean a = true;
boolean b = false;
System.out.println (a || b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : vrai
- Si un opérande est faux et que l'autre est vrai, le résultat de l'opération est vrai
public class Main
(
public static void main(String() args) (
boolean a = false;
boolean b = true;
System.out.println (a || b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : vrai
3) Égale à l'opérateur -
Cet opérateur est utilisé pour vérifier si l'opérande ou l'expression des deux côtés de l'opérateur sont égaux ou non
Exemple d'opérateur Egal à:
- Si les deux opérandes ne sont pas identiques, le résultat de l'opération est faux
public class Main
(
public static void main(String() args) (
String a = "abc";
String b = "abcd";
System.out.println (a == b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : faux
- Si les deux opérandes sont identiques, le résultat de l'opération est vrai
public class Main
(
public static void main(String() args) (
String a = "abc";
String b = "abc";
System.out.println (a == b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : vrai
4) Pas égal à l'opérateur
Cet opérateur est utilisé pour vérifier si l'opérande ou l'expression des deux côtés de l'opérateur sont égaux ou non. Il produit vrai si les opérandes des deux côtés ne sont pas identiques sinon donne faux
Exemples d'opérateur non égal à:
- Si les deux opérandes ne sont pas identiques, le résultat de l'opération est vrai
public class Main
(
public static void main(String() args) (
String a = "abc";
String b = "abcd";
System.out.println (a != b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : vrai
- Si les deux opérandes sont identiques, le résultat de l'opération est faux
public class Main
(
public static void main(String() args) (
String a = "abc";
String b = "abc";
System.out.println (a != b); // shows the logical operation using operator
)
)
Maintenant, exécutez le code ci-dessus
Sortie : faux
5) Opérateur ternaire-
Cet opérateur est utilisé pour vérifier les autres conditions. C'est généralement un raccourci pour l'instruction if-else. Si l'expression est vraie, alors si la partie est exécutée, sinon le bloc est exécuté. Il utilise deux opérandes qui sont?:
Voyons un exemple
public class Main
(
public static void main (String()args)(
int a = 2;
int b = 5;
int minOfNum = (a < b) ? a : b;
System.out.println (minOfNum);
)
)
Sortie : 2
Dans l'expression, (a <b)? a: b il évalue la valeur. Basé sur l'évaluation, il exécute le bloc if ou else
Conclusion -
Java est un langage de programmation où il y a beaucoup de concepts à étudier. Les opérateurs booléens en font partie. Ces opérateurs booléens exécutent essentiellement le code pour vérifier si la valeur de l'expression est vraie ou non. Sur la base de l'évaluation de l'expression, il renvoie la valeur. Un opérateur booléen est largement utilisé dans n'importe quel langage de programmation pour diverses expressions de programmation logique.
Articles recommandés
Cela a été un guide pour les opérateurs booléens en Java. Nous discutons ici de différents types d'opérateurs booléens en Java tels que l'opérateur logique ET, OU logique, égal à, différent de l'opérateur ternaire avec exemple. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Opérateurs Windows
- Opérateurs R
- Opérateurs Python
- Opérateurs Scala
- Opérateurs booléens en Python