Opérateurs relationnels en Java | Expliqué
Comment fonctionnent les opérateurs relationnels en Java
Les opérateurs relationnels utilisés dans Java sont identiques à tout autre langage de programmation. Chacun des opérateurs relationnels est défini ici, et une utilisation plus approfondie serait fournie dans la prochaine section.
Égal à (==): Cet opérateur vérifie la relation d'égalité entre les valeurs / variables en Java. Le symbole de l'opérateur est «==»Et est pratiqué en suivant la syntaxe fournie ci-dessous:
a == b;Inégal (!=):: Ceci est l'opposé de l'égal à l'opérateur car il vérifie l'inégalité de deux variables / valeurs. Le symbole pour utiliser cet opérateur est «!(=) ”Et la syntaxe suivante peut être suivie pour cet opérateur:
un!= b;Supérieur à (>). Le plus grand que l'opérateur vérifie si l'opérande sur le côté gauche est supérieur à l'autre ou non. La syntaxe de l'utilisation de l'opérateur supérieur à celle est indiquée ci-dessous:
a> b;Supérieur ou égal à (> =): Il montre si une variable est plus élevée ou égale à un autre. Le «plus grand ou égal à» est exercé en utilisant le symbole «> =» et il suit la syntaxe fournie ci-dessous.
a> = b;Moins que (<): Cet opérateur vérifie si la première variable / valeur est inférieure à la deuxième valeur / variable ou non. Vous pouvez vous référer à l'énoncé suivant pour utiliser cet opérateur.
unComment utiliser des opérateurs relationnels en Java
Cette section fournit l'utilisation des opérateurs relationnels en Java. Plus tard dans cette section, vous pourriez également connaître le fonctionnement des opérateurs relationnels dans les déclarations IF-Else et les boucles de la programmation Java.
Égal à (==): Le code Java suivant utilise l'opérateur «égal à» entre deux variables et renvoie le faux résultat car la variable x = 2 n'est pas égale à y = 4.
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int x = 2, y = 4;
Système.dehors.println (x == y);
La sortie du code est fournie ci-dessous:
Pas égal à(!=): Le programme Java suivant, A = 7 n'est pas égal à B = 9, mais l'opérateur non égal est retourné vrai dans la sortie.
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int a = 7, b = 9;
Système.dehors.println (un!= b);
La sortie du code s'affiche ci-dessous:
Moins que (<): Le code fourni ci-dessous compare les variables C et D en utilisant l'opérateur relationnel «moins que». Comme la valeur de la variable c = 10 est inférieur à d = 15, La sortie serait donc vraie:
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int c = 10, d = 15;
Système.dehors.println (c
La sortie du code est indiquée ci-dessous:
Supérieur à (>): Le code Java fourni ci-dessous utilise l'opérateur supérieur à deux variables (E et F). L'entier 18 est stocké en variable E alors que 12 est affecté à la variable F: Cela montre la valeur de F est supérieur à e Mais nous avons vérifié si f> e ou non.
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int e = 18, f = 12;
Système.dehors.println (f> e);
La sortie du code ci-dessus est fausse parce que le F
Supérieur ou égal à (> =): Le code fourni ci-dessous exerce le plus grand ou égal à l'opérateur sur deux variables. La condition (x> = y) définie dans le code est vraie, donc la sortie est également vraie:
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int x = 13, y = 13;
Système.dehors.println (x> = y);
La sortie du code est indiquée ci-dessous:
Inférieur ou égal à (<=): Cet opérateur est pratiqué sur deux variables un et b. Les valeurs attribuées à un et b sont 5 et 8 respectivement. L'ensemble de conditions est b<=a which is false thus the return would also be false.
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int a = 5, b = 8;
Système.dehors.println (b<=a);
La sortie du code peut être vue dans l'image ci-dessous:
Utilisation d'opérateurs relationnels dans des boucles et des déclarations IF-Else en Java
La pratique la plus courante des opérateurs relationnels est de les utiliser à l'intérieur des boucles et des déclarations conditionnelles IF-Else pour construire une condition.
Pour boucle: La boucle FOR est un type de boucle largement utilisé et le code écrit ci-dessous montre l'utilisation des boucles pour les opérateurs relationnels.
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int z = 2, i;
// en utilisant pour la boucle et <=
pour (i = 0; i<=z; i++)
Système.dehors.println ("La condition est vraie");
Le code est décrit comme:
- Déclarer les variables Z et I
- Utilisation de l'opérateur de boucle et relationnel (inférieur ou égal à)
- imprimer une déclaration
La sortie du code est indiquée ci-dessous:
if-else et opérateurs relationnels: Le code suivant démontre l'utilisation de l'IF-Else et de l'opérateur relationnel (>).
Package NewPack;classe publique Replot
public static void main (String [] args)
// déclarant les variables
int a = 4, b = 3;
// Utilisation de l'IF-Else et de l'opérateur relationnel
si (a> b)
Système.dehors.println ("La condition est vraie");
autre
Système.dehors.println ("faux!");
Le code est décrit ici:
- Déclacement des variables
- en utilisant le (a> b) comme condition dans la déclaration if
- Impression à l'intérieur des instructions if et sinon
La sortie du code est indiquée ci-dessous:
Conclusion
Les opérateurs relationnels de Java ont la responsabilité clé de vérifier la condition et de renvoyer le résultat en fonction de cette vérification des conditions. Les opérateurs relationnels Java sont pratiqués dans des déclarations et des boucles conditionnelles pour prendre des décisions dans les programmes. Cet article démontre le fonctionnement des opérateurs relationnels. De plus, plusieurs exemples sont fournis qui illustrent l'utilisation des opérateurs conditionnels individuellement ainsi que dans les déclarations et les boucles conditionnelles.