Programmation en Java – Les opérateurs

image_pdfimage_print

Java fournit un ensemble d’opérateurs pour manipuler des variables. Nous pouvons les diviser en des groupes comme suit:

  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs bit à bit
  • Opérateurs d’affectation
  • Autres opérateurs

 
 
Dans ce chapitre, nous allons voir le fonctionnement de chaque opérateur.
 

Opérateurs arithmétiques

Le tableau suivant présente tous les opérateurs arithmétiques supportés par le langage Java. Supposons que la variable A contenant la valeur 10 et que la variable B contenant la valeur 20.

OpérateurDescriptionExemple
+La sommeA + B = 30
La soustractionA − B = 10
La multiplicationA ∗ B = 200
La divisionB ∕ A = 2
%Modulo c’est le reste d’une division entier.B % A = 0
++Opérateur d’incrémentation qui consiste à ajouter 1 à une variable.A++ = 11
Opérateur de décrémentation qui consiste à retirer 1 à une variable.A– = 9
Exemple

Essayez l’exemple suivant pour comprendre tous les opérateurs arithmétiques disponibles dans Java

public class ClassTest {

   public static void main(String args[]) {
      int x = 4;
      int y = 2;
      int z = 6;
      int w = 8;

      System.out.println("x + y = " + (x + y) );
      System.out.println("x - y = " + (x - y) );
      System.out.println("x * y = " + (x * y) );
      System.out.println("y / x = " + (y / x) );
      System.out.println("y % x = " + (y % x) );
      System.out.println("z % x = " + (z % x) );
      System.out.println("x++   = " +  (x++) );
      System.out.println("y--   = " +  (x--) );

      // Vérifier la différence entre w++ et ++w
      System.out.println("w++   = " +  (w++) );
      System.out.println("++w   = " +  (++w) );
   }
} 

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant

x + y = 6
x - y = 2
x * y = 8
y / x = 0
y % x = 2
z % x = 2
x++   = 4
y--   = 5
w++   = 8
++w   = 10
Différence entre i++ et ++iDifférence entre i++ et ++ii++ est appelé post-incrémentation alors que ++i est appelée pré-incrémentation.     i++ affecte puis incrémente la valeur. Dans l’exemple ci-dessous, i++ incrémentera la valeur…Lire plus  

Opérateurs relationnels

Le tableau suivant montre tous les opérateurs relationnels supportés par Java. Supposons que la variable A contenant la valeur 10 et la variable B contenant la valeur 20 donc

OpérateurDescriptionExemple
==Vérifie si les deux opérandes sont égales ou non. Si oui, alors la condition est true.(A == B) est False.
!=Vérifie si les deux opérandes sont égales ou non. Si les valeurs ne sont pas égales, la condition est True.(A != B) est True.
>Vérifie si la valeur de l’opérande gauche est supérieure à la valeur de l’opérande droit. Si oui, alors la condition devient True.(A > B) est False.
<Vérifie si la valeur de l’opérande gauche est inférieure à la valeur de l’opérande droit. Si oui, alors la condition devient True.(A < B) est True.
>=Vérifie si la valeur de l’opérande gauche est supérieure ou égale à la valeur de l’opérande droit. Si oui, alors la condition devient True.(A >= B) est False.
<=Vérifie si la valeur de l’opérande gauche est inférieure ou égale à la valeur de l’opérande droit. Si oui, alors la condition devient True.(A <= B) est True.
Exemple

Essayez l’exemple suivant pour comprendre tous les opérateurs relationnels disponibles en Java

public class ClassTest {

   public static void main(String args[]) {
      int x = 10;
      int y = 20;

      System.out.println("x == y = "+ (x == y) );
      System.out.println("x != y = "+ (x != y) );
      System.out.println("x > y = "+ (x > y) );
      System.out.println("x < y = "+ (x < y) );
      System.out.println("y >= x = "+ (y >= x) );
      System.out.println("y <= x = "+ (y <= x) );
   }
} 

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant

x == y = false
x != y = true
x > y = false
x < y = true
y >= x = true
y <= x = false

 

 

Opérateurs logiques

Le tableau suivant montre tous les opérateurs logiques pris en charge par le langage Java. Supposons que la variable A contenant la valeur 1 et la variable B contenant la valeur 0.

OpérateurDescriptionExemple
&&Opérateur logique AND. Si les deux opérandes ne sont pas égaux à zéro, la condition devient True.(A && B) est False.
||Opérateur logique OR. Si l’un des deux opérandes est non nul, la condition devient True.(A || B) est True.
!Opérateur logique NOT. Il est utilisé pour inverser l’état logique de son opérande. Si une condition est True, l’opérateur NOT le rendra False.!(A && B) est True.
Exemple

Essayez l’exemple suivant pour comprendre tous les opérateurs logiques disponibles dans Java

public class ClassTest {

   public static void main(String args[]) {
      boolean x = true;
      boolean y = false;

      System.out.println("x && y = " + (x&&y));
      System.out.println("x || y = " + (x||y) );
      System.out.println("!(x && y) = " + !(x && y));
   }
}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant

x && y = false
x || y = true
!(x && y) = true

 
 

Opérateurs bit à bit

L’opérateur bit à bit fonctionne sur les bits et exécute l’opération bit par bit. Les tables de vérité pour &,, et ^ sont les suivantes

pqp & qp | qp ^ q
00000
01011
11110
10011

Supposons A = 60 et B = 13 en format binaire, ils seront comme suit –

A = 0011 1100

B = 0000 1101

—————–

A & B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

Essayez l’exemple suivant pour comprendre tous les opérateurs bit à bit disponibles dans Java

public class ClassTest {

   public static void main(String args[]) {
      int x = 60; // 60 = 0011 1100 
      int y = 13; // 13 = 0000 1101 
      int z = 0;

      z = x & y;        // 12 = 0000 1100 
      System.out.println("x & y = " + z );

      z = x | y;        // 61 = 0011 1101 
      System.out.println("x | y = " + z );

      z = x ^ y;        // 49 = 0011 0001 
      System.out.println("x ^ y = " + z );

      z = ~x;           //-61 = 1100 0011 
      System.out.println("~x = " + z );

      z = x << 2;       // 240 = 1111 0000 
      System.out.println("x << 2 = " + z );

      z = x >> 2;       // 15 = 1111 
      System.out.println("x >> 2  = " + z );

      z = x >>> 2;      // 15 = 0000 1111 
      System.out.println("x >>> 2 = " + z );
   }
}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant

x & y = 12
x | y = 61
x ^ y = 49
~x = -61
x << 2 = 240
x >> 2  = 15
x >>> 2 = 15

 
 

Opérateurs d’affectation

Le tableau suivant représente les opérateurs d’affectation pris en charge par le langage Java

OpérateurDescriptionExemple
=Opérateur d’affectation simple. Affecte les valeurs des opérandes de droite à l’opérande de gaucheC = A + B assignera la valeur de A + B à C
+=Il ajoute l’opérande droit à l’opérande gauche et affecte le résultat à l’opérande gauche.C += A est équivalent à C = C + A
-=Il soustrait l’opérande droit de l’opérande gauche et affecte le résultat à l’opérande gauche.C -= A est équivalent à C = C – A
*=Il multiplie l’opérande droit par l’opérande gauche et attribue le résultat à l’opérande gauche.C *= A est équivalent à C = C * A
/=Il divise l’opérande gauche par l’opérande droit et affecte le résultat à l’opérande gauche.C /= A est équivalent à C = C / A
%=Il prend le modulo en utilisant deux opérandes et attribue le résultat à l’opérande gauche.C %= A est équivalent à C = C % A
<<=Opérateur de décalage à gauche.C <<= 2 est identique à C = C << 2
>>=Opérateur de décalage à droiteC >>= 2 est identique à C = C >> 2
&=Opérateur bit à bit.C &= 2 est identique à C = C & 2
^=Opérateur OU exclusif bit à bit.C ^= 2 est identique à C = C ^ 2
|=Opérateur OU inclusive bit à bit.C |= 2 est identique à C = C | 2
Exemple

Essayez l’exemple suivant pour comprendre tous les opérateurs d’affectation disponibles en Java

public class ClassTest {

   public static void main(String args[]) {
      int x = 10;
      int y = 20;
      int z = 0;

      z = x + y;
      System.out.println("z = x + y = " + z );

      z += x ;
      System.out.println("z += x  = " + z );

      z -= x ;
      System.out.println("z -= x = " + z );

      z *= x ;
      System.out.println("z *= x = " + z );

      x = 10;
      z = 15;
      z /= x ;
      System.out.println("c /= x = " + z );

      x = 10;
      z = 15;
      z %= x ;
      System.out.println("z %= x  = " + z );

      z <<= 2 ;
      System.out.println("z <<= 2 = " + z );

      z >>= 2 ;
      System.out.println("z >>= 2 = " + z );

      z >>= 2 ;
      System.out.println("z >>= 2 = " + z );

      z &= x ;
      System.out.println("z &= x  = " + z );

      z ^= x ;
      System.out.println("z ^= x   = " + z );

      z |= x ;
      System.out.println("z |= x   = " + z );
   }
} 

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant

z = x + y = 30
z += x  = 40
z -= x = 30
z *= x = 300
c /= x = 1
z %= x  = 5
z <<= 2 = 20
z >>= 2 = 5
z >>= 2 = 1
z &= x  = 0
z ^= x   = 10
z |= x   = 10

 

Opérateur ternaire

Outre les opérateurs examinés ci-dessus, il existe quelques autres opérateurs importants dont sizeof et ? : sont pris en charge par le langage Java.

OpérateurDescriptionExemple
? :Expression conditionnelle.If Condition est True ? donc la valeur X : sinon la valeur Y

Essayez l’exemple suivant :

public class ClassTest {

   public static void main(String args[]) {
      int x, y;
      x = 10;
      y = (x == 1) ? 20: 30;
      System.out.println( "La valeur de y est:" + y );

      y = (x == 10) ? 20: 30;
      System.out.println( "La valeur de y est:" + y );
   }
}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant

La valeur de y est: 30
La valeur de y est: 20
Partagez cet article

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *