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)

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)
                                    }
                                }
                                            
                            

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);
                                    }
                                }
                            

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");
                                    }
                                }
                                
                            

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");
                                    }
                                }
                                

                            

Les opérateurs d’affectation sont utilisés en Java pour attribuer des valeurs aux variables.

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)

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.