Les opérateurs en Java
Java fournit un riche ensemble d'opérateurs pour manipuler des variables. Nous pouvons diviser tous les opérateurs Java dans les groupes suivants :
- Opérateurs arithmétiques (+, -, *, /,%, post-incrémentation, pré-incrémentation, post-décrémentation, pré-décrémentation)
- Opérateurs relationnels (==,! =,>, < ,> = & <=) Opérateurs logiques (&&, || et !)
- Opérateurs binaires (&, |, ^, ~, >> et <<)
- Opérateurs binaires (&, |, ^, ~, >> et <<)
- Opérateurs d'affectation (=, +=, -=, *=, etc)
Opérateurs arithmétiques
Ils sont utilisés pour effectuer des opérations arithmétiques/mathématiques sur les opérandes.
- Addition : L'opérateur ‘+’ ajoute deux opérandes. Par exemple, x+y.
- Soustraction: l'opérateur ‘ - ' soustrait deux opérandes. Par exemple, x-y.
- Multiplication: l'opérateur ’ * ' multiplie deux opérandes. Par exemple, x*y.
- Division: l'opérateur '/' divise le premier opérande par le second. Par exemple, x/y.
- Module: l'opérateur ' % ' renvoie le reste lorsque le premier opérande est divisé par le second. Par exemple, x%y).
Exemple 1 :
public class Test{ public static void main(String args[]){ var a = 10; var b = 4; res = a + b; # addition System.out.println("a+b : " + res) res = a - b; # soustraction System.out.println("a-b :" + res) res = a * b; # multiplication System.out.println("a*b :" + res) res = a / b; # division System.out.println("a/b : " + res) res = a % b; # Module System.out.println("a mod b :" + res) } }
a-b : 6
a*b : 40
a/b : 2.5
a mod b : 2
Ceux qui entrent dans la catégorie des opérateurs arithmétiques unaires sont:
- Incrémentation : L’opérateur «++» permet d’incrémenter la valeur d’un entier.
Quand il est est placé devant le nom de la variable (également appelé opérateur de pré-incrémentation), sa valeur est incrémentée instantanément. Par exemple, ++x.
Et quand il est placé après le nom de la variable (également appelé opérateur post-incrémentation), sa valeur est conservée temporairement jusqu'à l'exécution de cette instruction et est mise à jour avant l'exécution de l'instruction suivante. Par exemple, x++. - Décrémentation : L’opérateur "--" sert à décrémenter la valeur d’un entier.
Quand il est est placé avant le nom de la variable (également appelé opérateur de pré-décrémentation), sa valeur est décrémentée instantanément. Par exemple, --x.
Et quand il est placé après le nom de la variable (également appelé opérateur post-décrémentation), sa valeur est conservée temporairement jusqu'à l'exécution de cette instruction et elle est mise à jour avant l'exécution de l'instruction suivante. Par exemple, x--
Exemple 2 :
public class Test{ public static void main(String args[]){ int a = 10, res; // post-incrémentation: res = a++; System.out.println("a : " + a + " et res : " + res); // post-décrémentation res = a--; System.out.println("a : " + a + " et res : " + res); // pré-incrémentation res = ++a; System.out.println("a : " + a + " et res : " + res); // pré-décrémentation res = --a; System.out.println("a : " + a + " et res : " + res); } }
a : 10 et res : 11
a : 11 et res : 11
a : 10 et res : 10
Opérateurs relationnels et logiques
Opérateurs relationnels
Les opérateurs relationnels sont utilisés pour comparer deux valeurs.
- l'opérateur ‘==’ vérifie si les deux opérandes sont égales ou non. Si oui, il renvoie la valeur true. Sinon, il retourne false. Par exemple, 5==5 retournera true.
- ‘!=’ opérateur vérifie si les deux opérandes sont égaux ou non. elle renvoie la valeur true si les deux opérandes ne sont pas égaux, Sinon, il retourne false. C'est le complément booléen exact de l'opérateur‘==’. Par exemple, 5!=5 retournera false.
- L’opérateur ‘>’ vérifie si le premier opérande est supérieur au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 6> 5 retournera true.
- L’opérateur ‘<‘ vérifie si le premier opérande est inférieur au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 6 < 5 renverra false. <
- L’opérateur ‘> =’ vérifie si le premier opérande est supérieur ou égal au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 5> = 5 retournera true.
- L’opérateur ‘<=’ vérifie si le premier opérande est inférieur ou égal au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 5 <=5 retournera également true.
Exemple 3 :
public class Test{ public static void main(String args[]){ var a = 10; var b = 4; // supérieure à if (a > b) System.out.println("a est supérieure à b"); else System.out.println("a est inférieure ou égale à b"); // supérieure ou égale if (a >= b) System.out.println("a est supérieure ou égale à b"); else System.out.println("a est inférieure à b"); // inférieure à if (a < b) System.out.println("a est inférieure à b"); else System.out.println("a est supérieure ou égal b"); // inférieure ou égale if (a <= b) System.out.println("a est inférieure ou égale à b"); else System.out.println("a est supérieure à b"); // égales if (a == b) System.out.println("les valeurs a et b sont égales"); else System.out.println("a et b ne sont pas égales"); // ne sont pas égales if (a != b) System.out.println("les valeurs a et b ne sont pas égales "); else: System.out.println("les valeurs a et b sont égales b"); } }
a est supérieure ou égale à b
a est supérieure ou égal b
a est supérieure à b
a et b ne sont pas égales
les valeurs a et b ne sont pas égales
Opérateurs logiques
Ils sont utilisés pour combiner deux ou plusieurs conditions / contraintes ou pour compléter l'évaluation de la condition d'origine considérée.
Ils sont décrits ci-dessous:
- ET logique: l’opérateur "&&" retourne true lorsque les deux conditions considérées sont remplies. Sinon, il retourne false.
Par exemple, (a && b) renvoie true lorsque a et b sont vraies (c'est-à-dire différentes de zéro). - OU logique: l’opérateur "||" renvoie la valeur true lorsque l’une (ou les deux) des conditions considérées est remplie. Sinon, il retourne false.
Par exemple, un (a || b) renvoie true si l'un des a ou b est true (c'est-à-dire différente de zéro). Bien sûr, il retourne true lorsque a et b sont toutes les deux vraies. - NON logique: L’opérateur "!" Renvoie true si la condition considérée n’est pas remplie. Sinon, il retourne false. Par exemple, (!A) retourne vrai si a est false, c’est-à-dire quand a = 0.
Exemple 4 :
public class Test{ public static void main(String args[]){ int a = 10, b = 4, c = 10, d = 20; boolean bo = false; // ET logique if (a > b && c == d) System.out.println("a est supérieure à b ET c est égale à d"); else: System.out.println("condition ET non satisfaite"); // OU logique if (a > b || c == d) System.out.println("a est supérieure à b OU c est égale à d"); else System.out.println("Ni a n'est supérieure à b ni c n'est égale à d "); // NON logique if (!a) System.out.println("bo est fausse"); else System.out.println("a est vraie"); } }
a est supérieure à b OU c est égale à d
bo est fausse
Opérateurs d'affectation
Les opérateurs d’affectation sont utilisés en Java pour attribuer des valeurs aux variables.
Operateur | Exemple | Equivalente à |
---|---|---|
= | x = 5 | x = 5 |
+= | x += 5 | x = x + 5 |
-= | x -= 5 | x = x - 5 |
*= | x *= 5 | x = x * 5 |
/= | x /= 5 | x = x / 5 |
%= | x %= 5 | x = x % 5 |
&= | x &= 5 | x = x & 5 |
>>= | x >>= 5 | x = x >> 5 |
<<= | x <<= 5 | x = x << 5 |
Opérateurs binaires
Les opérateurs binaires sont utilisés pour effectuer des opérations sur les bits. Toutes les valeurs décimales seront converties en valeurs binaires (séquence de bits, à savoir 0100, 1100, 1000, 1001, etc.). Ensuite, les opérateurs au niveau des bits travailleront sur ces bits, en les décalant de gauche à droite ou en convertissant les valeurs de bits de 0 à 1, etc.
Dans le tableau ci-dessous: Soit x = 10 (0000 1010 en binaire) et y = 4 (0000 0100 en binaire)
Operateur | signification | Exemple |
---|---|---|
& | ET logique | x& y = 0 (0000 0000 ) |
| | OU logique | x | y = 14 (0000 1110 ) |
~ | NON logique | ~x = -11 (1111 0101 ) |
^ | XOR | x ^ y = 14 (0000 1110 ) |
>> | Décalage binaire à droite | x>> 2 = 2 (0000 0010 ) |
<< | Décalage binaire à gauche | x<< 2 = 40 (0010 1000 ) |
Priorité des opérateurs en Java
La priorité des opérateurs détermine le regroupement des termes dans une expression. Cela affecte la manière dont une expression est évaluée. Certains opérateurs ont une priorité plus élevée que d’autres; par exemple, l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition -
Ici, les opérateurs avec la priorité la plus élevée apparaissent en haut du tableau, ceux avec la plus basse apparaissent en bas. Dans une expression, les opérateurs de priorité les plus élevés seront évalués en premier.
Categorie | Operateurs | Associativité |
---|---|---|
Unaire | ++ –- + ~ ! | De droite à gauche |
Multiplicative | * / % | De gauche à droite |
Additive | + - | De gauche à droite |
Déclage | << >> >>> | De gauche à droite |
Relationnelle | < > <= >= instanceof | De gauche à droite |
Égalité | == != | De gauche à droite |
ET binaire | & | De gauche à droite |
XOR | ^ | De gauche à droite |
OU binaire | | | De gauche à droite |
ET logique | && | De gauche à droite |
OU logique | || | De gauche à droite |
Conditionnelle | ?: | De droite à gauche |
Affectation | = += -= *= /= %= ^= |= <<=>>= >>>= | De droite à gauche |