Introduction aux opérateurs Java : logique, arithmétique, au niveau du bit

Parlons des opérations en Java : numériques, logiques, au niveau des bits. Il s’agit d’une base théorique indispensable pour apprendre à programmer.

• Quels sont les types d’opérateurs en Java ?
• Opérateurs Java dans le cours JavaRush
• Opérations sur les nombres en Java
• Opérations logiques en Java
• Opérations au niveau du bit en Java
• Priorité des opérations en Java
• Exemples d'utilisation utiles

Quels sont les types d’opérateurs en Java ?

Pour toute opération, nous avons besoin d'au moins deux choses :

• opérateur;
• opérande.

Un exemple d'opérateur serait un simple plus dans l'opération d'addition de deux nombres. Et les nombres ajoutés les uns aux autres seront dans ce cas des opérandes. Ainsi, à l'aide d'opérateurs, nous effectuons des opérations sur un ou plusieurs opérandes. Les opérateurs qui effectuent des opérations sur deux opérandes sont appelés binaires. Par exemple, additionner deux nombres. Les opérateurs qui effectuent des opérations sur un seul opérande sont appelés unaires. Par exemple, un moins unaire.

Opérateurs Java dans le cours JavaRush

Plusieurs conférences sont consacrées aux opérateurs Java au quatrième niveau de la première quête - Java Syntax. En particulier, les opérateurs conditionnels tels que boolean . Le cours contient 22 tâches qui vous aideront à comprendre le travail des opérateurs de comparaison, des opérateurs conditionnels et des opérateurs logiques.

Opérations sur les nombres en Java

L'opération la plus courante que les programmeurs effectuent sur les nombres consiste à attribuer une valeur numérique à une variable. Elle, comme l'opératrice, =vous est familière :

int a = 1;
int b = 2;
int c = 3;

Il existe également des opérations arithmétiques. Elles sont réalisées à l'aide d'opérateurs arithmétiques binaires : Tableau 1. Opérateurs arithmétiques binaires Les quatre premiers opérateurs ne devraient pas poser de questions : tout est comme en mathématiques. Le dernier opérateur, le reste de la division, ne fait rien non plus de trop compliqué. Par exemple, si l’on divise 24 par 7, on obtient 3 nombres entiers et 3 restes. C'est le reste que cet opérateur renverra :

System.out.println(24 % 7); // prints 3

Voici des exemples tirés du site de documentation officiel d'Oracle : Ce programme affichera ce qui suit : 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 Java vous permet à combiner : par exemple, affectations d'opérateurs et opérateurs arithmétiques. Regardons un exemple :

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

Ici, nous avons défini une variable xet lui avons attribué la valeur zéro. Ensuite, dans chaque ligne, nous attribuons une valeur xà la somme de la valeur actuelle de la variable xet un. Il y a des explications dans les commentaires pour chaque ligne. Cette procédure est appelée croissance ou incrémentation d'une variable. L'opération d'incrémentation de l'exemple ci-dessus peut être remplacée par une opération similaire en utilisant une combinaison d'opérateurs :

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

Vous pouvez combiner l'opérateur d'affectation avec n'importe quel opérateur arithmétique :

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

Montrons comment fonctionne le dernier exemple : En plus des opérateurs binaires, Java possède des opérateurs arithmétiques unaires. Tableau 2. Opérateurs arithmétiques unaires : Exemple de plus et moins unaire :

int x = 0;
x = (+5) + (+15); // Parentheses for clarity, it is possible without them
System.out.println("x = " + x);

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

Les opérations d'incrémentation et de décrémentation sont essentiellement simples. Dans le premier cas, la variable est augmentée de 1, dans le second, la variable est diminuée de 1. L'exemple est ci-dessous :

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

Il existe deux types de ces opérations : le suffixe et le préfixe. Dans le premier cas, l'opérateur est écrit après la variable, dans le second cas, avant la variable. La seule différence réside dans le moment où l'opération d'incrémentation ou de décrémentation est effectuée. Exemple et description dans le tableau ci-dessous. Disons que nous avons une variable :

int a = 2;

Alors: Tableau 3. Opérateurs d'incrémentation-décrémentation : Manifestation: En plus de l'arithmétique, il existe des opérations de comparaison (de deux nombres). Le résultat sera toujours vrai ou faux ( true / false ). Tableau 4. Opérateurs de comparaison Exemples:

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

Manifestation:

Opérations logiques en Java

Regardons les opérations logiques et les tables de vérité de chacun d'eux :

• opération de négation ( NOT);
• opération de conjonction, ET logique ( AND);
• opération de disjonction, OU logique ( OR);
• opération d'addition modulo, OU exclusif ( XOR).

L'opérateur de négation est unaire et s'applique à un seul opérande. Toutes les autres opérations sont binaires. Considérons les tables de vérité de ces opérations. Ici, 0 est l'équivalent de false en Java et 1 est l'équivalent de true . Tableau 5. Table de vérité des opérateurs de négation (NON) Tableau 6. Table de vérité de l'opérateur de conjonction (AND) Tableau 7. Table de vérité de l'opérateur de disjonction (OR) Tableau 8. Table de vérité de l'opérateur d'addition modulo (XOR) Java a les mêmes opérations logiques :

• !— opérateur de négation ;
• &&— opérateur logique ET (court) ;
• ||— opérateur logique OU (court) ;
• &— opérateur ET au niveau du bit ;
• |— opérateur OU au niveau du bit ;
• ^— opérateur OU exclusif au niveau du bit.

Examinons ci-dessous la différence entre les opérateurs au niveau du bit et les opérateurs raccourcis, tout en convertissant toutes les tables de vérité en code Java :

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

Ce programme affichera : PAS EXEMPLE : PAS faux = vrai PAS vrai = faux ET EXEMPLE : faux ET faux = faux faux ET vrai = faux vrai ET faux = faux vrai ET vrai = vrai OU EXEMPLE : faux OU faux = faux faux OU vrai = vrai vrai OU faux = vrai vrai OU vrai = vrai XOR EXEMPLE : faux XOR faux = faux faux XOR vrai = vrai vrai XOR faux = vrai vrai XOR vrai = faux Les opérateurs logiques s'appliquent uniquement aux booleanvariables. Dans notre cas, nous les avons appliqués directement aux valeurs, mais vous pouvez également les utiliser avec booleandes variables : Et aux booleanexpressions : Maintenant, nous avons des opérateurs abrégés ( &&, ||) et des opérateurs binaires similaires ( &, |). Quelle est la différence entre eux? Premièrement, le bitwise peut être appliqué à des nombres entiers. Nous en reparlerons un peu plus tard. Et deuxièmement, certains sont abrégés, d’autres non. Pour comprendre à quoi ressemble l'abréviation, regardons l'expression :

false AND x = ?
true OR x = ?

Cela xpeut prendre n'importe quelle valeur booléenne. Et en général, selon les lois de la logique et des tables de vérité, que ce soit x vrai ou faux , le résultat de la première expression sera faux et le résultat de la seconde sera vrai . Regarder. Parfois, le résultat d’une expression peut être calculé à partir du premier opérande. C'est ce qui distingue les opérateurs abrégés &&et ||. Dans des expressions similaires à celles décrites ci-dessus, ils n'évaluent pas la valeur du deuxième opérande. Voici un petit exemple : Dans le cas d'opérateurs abrégés, la deuxième partie de l'expression n'est pas évaluée. Mais cela n’arrive que lorsque le résultat de l’expression est déjà évident dès le premier opérande.

Opérations au niveau du bit en Java

Eh bien, nous arrivons ici à la partie la plus intéressante : les opérations au niveau du bit. Comme son nom l’indique, ce sont des opérations effectuées sur des bits. Mais avant d’aborder ce sujet, il convient de parler de domaines connexes.

Représentation des nombres dans le système de nombres binaires

Les nombres, comme toute autre information contenue dans un programme, sont stockés dans la mémoire de l'ordinateur sous forme de code binaire. Le code binaire est un ensemble de zéros et de uns. Chaque zéro ou un représente une unité d'information appelée bit.

D'après Wikipédia :

Un bit (de l'anglais binaire chiffre - nombre binaire ; également un jeu de mots : anglais bit - morceau, particule) est une unité de mesure de la quantité d'informations. 1 bit d'information est un symbole ou un signal qui peut prendre deux significations : allumé ou éteint, oui ou non, haut ou bas, chargé ou non chargé ; dans le système binaire, c'est 1 (un) ou 0 (zéro).

Avec quels types de données les opérateurs au niveau du bit travaillent-ils ?

Les opérations au niveau du bit en Java sont effectuées uniquement sur des entiers. Les entiers sont stockés dans la mémoire de l'ordinateur sous forme d'ensemble de bits. Nous pouvons dire qu'un ordinateur convertit n'importe quelle information en un système de nombres binaires (un ensemble de bits) et interagit ensuite seulement avec lui. Mais comment fonctionne le système de nombres binaires ? Dans le système de nombres décimaux, nous n'avons que 10 symboles : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Nous utilisons ces symboles pour compter. Après 9 vient 10, après 19 - 20, après 99 - 100, après 749 - 750. Autrement dit, nous utilisons une combinaison des 10 symboles disponibles et pouvons les utiliser pour compter « de zéro jusqu'au déjeuner ». Dans le système de nombres binaires, au lieu de dix symboles, il n'y en a que deux - 0, 1. Mais en combinant ces symboles selon le même principe que dans le système décimal, on peut compter indéfiniment. Montrons le comptage de 0 à 15 en décimal et binaire : Comme vous pouvez le constater, tout n'est pas si compliqué. En plus des bits, il existe d'autres unités d'information familières - octets , kilo-octets , mégaoctets , gigaoctets , etc. Vous savez probablement qu'il y a 8 bits dans 1 octet . Qu'est-ce que ça veut dire? Cela signifie que 8 bits consécutifs occupent 1 octet. Voici des exemples de ce que peuvent être les octets :

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

Le nombre de combinaisons non répétitives possibles de bits dans un octet est de 256 (2 ⁸ = 256). Mais revenons plus près de Java. Il existe un tel type de données entier - byte. Ce type peut prendre des valeurs de -128 à 127 et un nombre dans la mémoire de l'ordinateur occupe exactement 8 bits, soit 1 octet. Un numéro de ce type occupe exactement 1 bytemémoire de l'ordinateur. Et ici, les noms ne coïncident pas par hasard. On s’en souvient, 1 octet peut stocker 256 valeurs différentes. Et un numéro de type bytepeut prendre 256 valeurs différentes (128 négatives, 127 positives et 1 zéro). Chaque valeur numérique bytepossède un ensemble unique de huit bits. C'est le cas non seulement du type byte, mais de tous les types intégraux. Le type byteest donné à titre d'exemple comme étant le plus petit. Le tableau ci-dessous montre tous les types entiers Java et l'espace mémoire qu'ils occupent : Considérez le type int. Il peut stocker 2147483648 valeurs négatives, 2147483647 valeurs positives et un zéro. Total:

2147483648 + 2147483647 + 1 = 4294967296.

Ce type occupe 32 bits dans la mémoire de l'ordinateur. Le nombre de combinaisons possibles parmi un ensemble de 32 zéros et uns est :

232 = 4294967296.

Le même nombre que le nombre de valeurs que le type peut contenir int. Ceci est juste une démonstration de la relation entre la plage de valeurs d'un type de données et sa taille (nombre de bits en mémoire). N'importe quel nombre de n'importe quel type en Java peut être converti en binaire. Voyons avec quelle facilité cela peut être réalisé en utilisant le langage Java. Nous apprendrons de l'exemple du type int. Ce type a sa propre classe wrapper - Integer. Et il en a un toBinaryString, qui fera tout le travail à notre place : Voilà, ce n'est pas si compliqué. Mais il reste quand même quelque chose à clarifier. intle nombre prend 32 bits. Mais lorsque nous imprimons le nombre 10 dans l’exemple ci-dessus, nous voyons 1010 dans la console. En effet, les zéros non significatifs ne sont pas imprimés. S'ils étaient affichés, au lieu de 1010, nous verrions sur la console 00000000000000000000000000001010. Mais pour faciliter la perception, tous les zéros non significatifs sont omis. Ce n’est pas si difficile jusqu’à ce que vous vous demandiez : qu’en est-il des nombres négatifs ? Il perçoit les informations uniquement dans le système binaire. Il s'avère que le signe moins doit également être écrit en code binaire. Cela peut être fait en utilisant du code direct ou complémentaire.

Code direct

Méthode de représentation des nombres dans le système de nombres binaires, dans laquelle le bit le plus significatif (le bit le plus à gauche) est attribué au signe du nombre. Si le nombre est positif, le bit le plus à gauche est écrit 0, s'il est négatif - 1. Regardons cela en utilisant un nombre de 8 bits comme exemple : L'approche est simple et, en principe, compréhensible. Elle présente cependant des inconvénients : des difficultés à réaliser des opérations mathématiques. Par exemple, en ajoutant des nombres négatifs et positifs. Ils ne peuvent être pliés que si des manipulations supplémentaires sont effectuées.

Code supplémentaire

En utilisant du code supplémentaire, vous pouvez éviter les inconvénients du code direct. Il existe un algorithme simple pour obtenir le code supplémentaire d’un numéro. Essayons d'obtenir le code supplémentaire pour le numéro -5. Représentons ce nombre en utilisant le code complément à deux dans le système de nombres binaires. Étape 1. Nous obtenons une représentation d'un nombre négatif en utilisant un code direct. Pour -5, ce sera 10000101. Étape 2. Inversez tous les chiffres sauf le chiffre du signe. Remplaçons tous les zéros par des uns, et les uns par des zéros partout sauf le bit le plus à gauche.

10000101 => 11111010

Étape 3. Ajoutez-en un à la valeur résultante :

11111010 + 1 = 11111011

Prêt. Nous avons obtenu la valeur de -5 dans le système de nombres binaires en utilisant le code complément à deux. Ceci est important pour comprendre les éléments suivants, car Java utilise le code du complément à deux pour stocker les nombres négatifs en bits.

Types d'opérations au niveau du bit

Maintenant que nous avons traité toutes les introductions, parlons des opérations au niveau du bit en Java. Une opération au niveau du bit est effectuée sur des entiers et son résultat est un entier. Au cours du processus, le nombre est converti en binaire, une opération est effectuée sur chaque bit et le résultat est reconverti en décimal. La liste des opérations se trouve dans le tableau ci-dessous : Comme nous l'avons déjà découvert, les nombres peuvent être représentés comme un ensemble de bits. Les opérations au niveau du bit effectuent des opérations sur exactement chaque bit d'une telle représentation. Prenons NOT, AND, OR, XOR. Rappelez-vous que nous avons récemment examiné les tables de vérité uniquement pour les opérandes logiques. Dans ce cas, les mêmes opérations sont appliquées à chaque bit de l'entier.

Opérateur unaire au niveau du bit NON ~

Cet opérateur remplace tous les zéros par des uns et tous les uns par des zéros. Disons que nous avons le nombre 10 en notation décimale. En binaire, ce nombre est 1010. Si nous appliquons l'opérateur de négation unaire au niveau du bit à ce nombre, nous obtenons quelque chose comme ceci : Voyons à quoi cela ressemble dans le code Java :

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

Voyons maintenant ce qui est affiché dans la console : Dans la première ligne, nous avons obtenu la valeur dans le système de nombres binaires sans zéros non significatifs. Même si nous ne les voyons pas, ils sont là. Ceci est démontré par la deuxième ligne, dans laquelle tous les bits ont été transformés en bits inversés. C'est pourquoi nous voyons tant d'unités dirigeantes. Il s'agit d'anciens zéros non significatifs qui ont été ignorés par le compilateur lors de l'impression sur la première ligne. Voici un petit programme qui affiche également les zéros non significatifs pour plus de clarté.

Opérateur ET au niveau du bit

Cet opérateur s'applique à deux nombres. Il effectue une opération ANDentre les bits de chaque nombre. Regardons un exemple : Cette opération est effectuée sur deux nombres. Exemple en code Java :

Opérateur OU au niveau du bit

OU s'applique à deux nombres. Il effectue une opération OU entre les bits de chaque nombre : Voyons maintenant à quoi cela ressemblerait dans IDEA :

Opération au niveau du bit, OU exclusif (XOR)

Regardons le même exemple, mais avec une nouvelle opération : Exemple de code :

Décalage au niveau du bit vers la gauche

Cet opérateur est applicable à deux opérandes, c'est-à-dire que dans l'opération x << y, les bits du nombre xse déplaceront yvers la gauche. Qu'est-ce que ça veut dire? Regardons l'exemple de l'opération. 10 << 1 Le résultat de l'opération sera le nombre 20 dans le système décimal. Comme vous pouvez le voir sur le schéma ci-dessus, tous les bits sont décalés de 1 vers la gauche. Lors de cette opération, la valeur du bit de poids fort (le bit le plus à gauche) est perdue. Et le bit le moins significatif (le bit le plus à droite) est rempli de zéro. Que pouvez-vous dire de cette opération ?

1. En décalant les bits d'un nombre Xpar Nbits vers la gauche, on multiplie le nombre Xpar 2 ^N .

   Voici un exemple :

2. Mais! Le signe du nombre peut changer si le bit de valeur 1 prend la position la plus à gauche.

3. Si vous vous déplacez indéfiniment vers la gauche, le nombre se transformera simplement en 0. Démontrons les points 2 et 3 :

Décalage au niveau du bit vers la droite

Cet opérateur s'applique à deux opérandes. Ceux. dans l'opération x >> y, les bits du nombre xse déplaceront yvers la droite. Regardons un autre exemple. Analysons schématiquement le fonctionnement 10 >> 1. Décalons tous les bits du nombre 10 d'une position vers la droite : Lors de l'opération de décalage, on perd les bons bits. Ils disparaissent tout simplement. Le bit le plus à gauche est le signe du nombre (0 est positif, 1 est négatif). Par conséquent, dans la valeur finale, il est placé de la même manière que dans le numéro d'origine. Exemple avec un nombre négatif : Le bit le plus à droite est perdu, et le bit le plus à gauche est copié du numéro d'origine, en signe honoraire du numéro. Comment faire tout cela dans IDEA ? En principe, rien de compliqué, il suffit de le prendre et de le déplacer : Maintenant. Que pouvez-vous dire des chiffres décalés vers la droite ? Ils sont divisibles par 2. Chaque fois que l'on décale d'un bit vers la droite, on divise le nombre d'origine par 2. Si le nombre n'est pas divisible par 2, le résultat sera arrondi vers moins l'infini (vers le bas). Mais cela ne fonctionne que si nous décalons les bits d'exactement 1. Et si de 2 bits, divisez par 4. Par 3 bits, divisez par 8. Par 4 bits, divisez par 16. Vous voyez ? Puissances de 2... Lorsque l'on décale un nombre Xvers Nla droite de bits, on divise le nombre Xpar 2 à la puissance 2 N. Manifestation:

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

Que se passe t-il ici?

1. Une boucle dans laquelle la variable i est incrémentée de 1 à 10.

2. A chaque itération nous calculons 2 valeurs :

• On écrit dans la variable shiftOperationResultle résultat du décalage du nombre 2048 de i bits vers la droite ;

• devideOperationResultNous écrivons le résultat de la division du nombre 2048 par 2 à la puissance i dans une variable .

3. Nous affichons les deux valeurs obtenues par paires.

Le résultat de l'exécution du programme est le suivant : 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

Décalage à droite au niveau du bit avec remplissage nul

Alors qu'un décalage vers la droite normal préserve le signe du nombre (le bit le plus significatif conserve sa valeur), un décalage vers la droite avec remplissage par zéro ne le fait pas. Et le bit le plus significatif est rempli de zéro. Voyons à quoi cela ressemble :

Priorité des opérations en Java

Comme les mathématiques, Java a la priorité sur les opérations. Le tableau ci-dessous montre la priorité (de la plus élevée à la plus basse) des opérations que nous avons considérées.

Exemples d'utilisation utiles

Déterminer la parité d'un nombre

Trouver l'élément maximum dans un tableau

Pour trouver l'élément minimum, changez simplement le signe de comparaison au bon endroit.