JavaRush /Blog Java /Random-FR /Opérations sur les nombres en Java

Niveau 41

28 février 2021
42 views
0 comments

Opérations sur les nombres en Java

Bonjour! Aujourd'hui, nous allons aborder un sujet très important, à savoir les opérations sur les nombres en Java . Les nombres sont partout dans la programmation. Si vous fouillez dans le programme scolaire, vous vous souviendrez que toutes les informations sur un ordinateur sont présentées dans un format numérique - des combinaisons de zéros et de uns - également appelé code binaire.

Il existe de très nombreuses opérations sur les nombres en programmation, nous allons donc examiner les plus importantes d'entre elles avec des exemples :)

Opérations arithmétiques

Commençons par le plus simple : les opérations arithmétiques. Il s'agit des célèbres additions (+ signe), soustraction (-), multiplication (*) et division (/).

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Sortie de la console :

Vous avez déjà utilisé tout cela. Vous pouvez leur ajouter une opération %- le reste de la division.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Sortie de la console :

Dans cet exemple, nous divisons 33 par 2. En conséquence, nous obtenons 16 et il reste une « queue » supplémentaire qui n'est pas divisible par 2 - un. Cette « queue » sera le résultat de l'opération « reste de division ». Java (ainsi que les mathématiques) implémente des opérateurs de comparaison . Vous les connaissez probablement aussi à l'école :

équivaut à ( ==)
plus ( >)
moins ( <)
Plus grand ou égal à ( >=)
inférieur ou égal à ( <=)
inégal ( !=)

Ici, il convient de prêter attention à un point important sur lequel de nombreux débutants commettent des erreurs. L'opération « égal » s'écrit ==, et non avec un seul signe =. Le signe d'unité =en Java est un opérateur d'affectation, dans lequel une variable se voit attribuer un nombre, une chaîne ou la valeur d'une autre variable. Opérations sur les nombres en Java - 3

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// expect false to be printed to the console
   }
}

Sortie de la console :

Oops! Ce n’est clairement pas le résultat auquel nous nous attendions. Il s’agit d’un type de données complètement différent : nous nous attendions à voir boolean, mais nous avons obtenu un nombre. En effet, entre parenthèses, nous avons une opération d'affectation, pas une comparaison. x=y La valeur y(999) a été attribuée à la variable x, puis nous l'avons imprimée xsur la console. Bonne option :

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Sortie de la console :


false

Nous avons maintenant correctement comparé les 2 chiffres ! :) Une autre particularité de l'opération d'affectation ( =) est qu'elle peut être effectuée « enchaînée » :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Sortie de la console :

N'oubliez pas : l'affectation se fait de droite à gauche. Cette expression ( x = y = z) sera exécutée par étapes :

y = z, c'est-à-dire y = 256
x = y, soit x = 256

Opérations unaires

Ils sont appelés « unaires » du mot « uno » - « un ». Ils ont reçu ce nom car, contrairement aux précédents, ils sont réalisés sur un seul numéro, et non sur plusieurs. Ceux-ci inclus:

Unaire moins. Il inverse le signe du nombre.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // change the sign for the first time
       x = -x;
       System.out.println(x);

       // change the sign a second time
       x= -x;
       System.out.println(x);
   }
}

Sortie de la console :


-999
999

Nous avons utilisé le moins unaire deux fois. En conséquence, notre chiffre est devenu négatif d’abord, puis à nouveau positif !

Incrément ( ++) et décrément ( --)

Une opération ++augmente un nombre de un, et une opération --le diminue de la même unité.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Sortie de la console :


1000
999

Cette forme de notation vous est peut-être familière si vous avez entendu parler du langage C++. À l’aide d’un nom aussi intéressant, ses créateurs ont exprimé leur idée : « C++ est une extension du langage C ». Une version améliorée populaire de Notepad s'appelle Notepad++. Point important. Il existe deux types d'opérations d'incrémentation et de décrémentation : suffixe et préfixe. x++- notation postfixe ++x- notation préfixe Quelle est la différence fondamentale si vous mettez des plus et des moins avant ou après le nombre ? Voyons dans un exemple :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Sortie de la console :

Y a-t-il quelque chose qui ne va pas! Nous voulions incrémenter xde 1 et attribuer une nouvelle valeur à la variable y. Autrement dit, y devrait être égal à 1000. Mais nous avons un résultat différent - 999. Il s'avère qu'il xn'a pas été augmenté et que l'opération d'incrémentation n'a pas fonctionné ? Comment ça a fonctionné. Pour vérifier cela, essayez d'imprimer x sur la console à la fin :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Sortie de la console :


999
1000

En fait, c'est pourquoi l'opération postfix est appelée ainsi : elle est effectuée après l'expression principale. Autrement dit, dans notre cas : int y = x++; il est d'abord exécuté y = x(et la variable y se verra attribuer la valeur initiale x), et seulement ensuite x++ . Et si nous ne sommes pas satisfaits de ce comportement ? Vous devez utiliser la notation de préfixe :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

Dans ce cas, cela fonctionnera d'abord ++x et seulement après. y = x; Cette différence mérite d'être rappelée tout de suite pour ne pas se tromper dans un programme réel, dans lequel tous les comportements peuvent être bouleversés à cause de cela :)

Opérations combinées

De plus, en Java, il existe des opérations dites combinées. Ils utilisent une combinaison de deux opérations :

Affectation
Opération arithmétique

Cela comprend les opérations :

+=
-=
*=
/=
%=

Regardons un exemple :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Sortie de la console :

x += ymoyens x = x + y. Par souci de concision, deux caractères consécutifs sont utilisés. Cela fonctionne également avec des combinaisons de -=, *=, /=et %=.

Opérations logiques

En plus des opérations sur les nombres, Java propose également des opérations sur les variables booléennes - trueet false. Ces opérations sont effectuées à l'aide d'opérateurs logiques

!— Opérateur « NON ». Inverse la valeur d'une variable booléenne

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Sortie de la console :


false

&&— l'opérateur "ET". Renvoie une valeur trueuniquement si les deux opérandes sont true.
```
public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}
```
Sortie de la console :
```
false
true
```
Le résultat de la première opération est false, puisqu'une des conditions est fausse, à savoir 100 > 200. L'opérateur exige que toutes les conditions soient vraies (comme dans la deuxième ligne par exemple) &&pour renvoyer .true
||— Opérateur « OU ». Renvoie truelorsqu'au moins un des opérandes est vrai.

Ici, notre exemple précédent fonctionnera différemment :
```
public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}
```
Sortie de la console :
```
true
```
Выражение 100 > 200 по-прежнему ложно, но оператору “or” вполне достаточно, что первая часть (100 > 10) является истинной.

Commentaires

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION