Guide des classes entières Java

Dans cet article, nous parlerons de la classe Integer. Considérons ces questions :

• que sont les classes wrapper ;
• emballage/déballage automatique des primitives ;
• fonctionnement de la classe Integer, de ses méthodes et constantes.

Classes wrapper de types primitifs

Comme vous le savez, Java possède différents types de données, qui peuvent être divisés en deux blocs :

• primitif;
• référence.

Il existe plusieurs types de données primitifs en Java :

• entiers - octet, court, int, long ;
• nombres à virgule flottante (réels) - float, double ;
• type de données logique - booléen ;
• type de données caractère - char.

Chaque type de données primitif possède sa propre classe wrapper. Un type de données de référence qui enveloppe son petit frère primitif dans un objet Java. Vous trouverez ci-dessous les types de données primitifs et leurs classes wrapper correspondantes : D'un point de vue pratique, les primitives et leurs classes wrapper ont beaucoup en commun. La plupart des opérations sont effectuées de manière identique. Cependant, les classes wrapper ont un certain nombre de caractéristiques qui ne sont pas caractéristiques des primitives. Premièrement, il y a les classes : lorsque nous travaillons avec des classes wrapper, nous travaillons avec des objets. Deuxièmement (tout ce qui suit découle du premier point), ces objets peuvent être nuls. Troisièmement, les classes wrapper fournissent un certain nombre de constantes et de méthodes qui facilitent le travail avec un type de données particulier. Dans cet article, nous examinerons de plus près l'utilisation de la classe Integer.

L' entier

La classe Integer est une classe wrapper de type primitif int. Cette classe contient un seul champ de type int. En tant que classe wrapper, Integer fournit diverses méthodes pour travailler avec des ints, ainsi qu'un certain nombre de méthodes pour convertir int en String et String en int. Ci-dessous, nous examinerons divers exemples de travail avec la classe. Commençons par la création. La plus couramment utilisée (et la plus simple à utiliser) est l’option de création suivante :

Integer a = 3;

Autrement dit, l'initialisation d'une variable Integer dans ce cas est similaire à l'initialisation d'une variable int. De plus, une variable Integer peut être initialisée avec la valeur d'une variable int :

int i = 5;
Integer x = i;
System.out.println(x); // 5

Dans le cas ci-dessus, l’autopacking se produit implicitement. Nous en parlerons davantage ci-dessous. En plus des options d'initialisation listées ci-dessus, une variable Integer peut être créée comme les autres objets, à l'aide d'un constructeur et du mot-clé new :

Integer x = new Integer(25);
System.out.println(x);

Cependant, l'écriture et la lecture prennent plus de temps, cette option est donc la moins courante. Vous pouvez faire tout ce que vous pouvez faire avec des variables entières avec des variables entières. Ils peuvent être: Cependant, avec tout cela, vous devez être prudent et vous rappeler qu'Integer est un type de données de référence et qu'une variable de ce type peut être nulle. Dans ce cas (si la variable est nulle), il vaut mieux s'abstenir d'opérations arithmétiques (et toutes autres dans lesquelles null n'augure rien de bon). Voici un exemple :

Integer a = null;
Integer b = a + 1; // Здесь мы упадем с "Exception in thread "main" java.lang.NullPointerException"
System.out.println(b);

La plupart des opérations de comparaison sont effectuées de la même manière que dans le type primitif int :

Integer a = 1;
Integer b = 2;

System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <= b);

Sortir:

false
false
true
true

L'opération de comparaison de deux variables entières se démarque. Et le point ici est qu'Integer est un type de données de référence et que ses variables stockent des références à des valeurs, et non aux valeurs elles-mêmes (objets). Des manifestations de ce fait peuvent être observées lors de l'exécution du fragment de code suivant :

Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);

System.out.println(a == b); // true
System.out.println(a == c); // false

Le résultat de la première égalité sera vrai et la seconde sera fausse. Cela se produit parce que dans le premier cas, nous comparons deux variables (« a » et « b ») qui stockent des références au même objet. Et dans le deuxième cas, on compare deux variables qui font référence à deux objets différents (lors de la création de la variable « c », nous avons créé un nouvel objet). Donnons un autre exemple intéressant :

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

System.out.println(a == b); // true
System.out.println(x == y); // false

Comme nous pouvons le constater, le résultat de la première comparaison est vrai et celui de la seconde est faux. Tout est question de mise en cache. Tous les entiers compris entre -128 et 127 inclus (ces valeurs peuvent être personnalisées) sont mis en cache. Ainsi, lorsque nous créons une nouvelle variable et lui attribuons une valeur entière comprise entre -128 et 127, nous ne créons pas un nouvel objet, mais attribuons plutôt à la variable une référence à un objet déjà créé dans le cache. Maintenant, sachant ce fait, l’exemple ci-dessus ne semble pas si mystique. Les variables a et b font référence au même objet – un objet du cache. Et lors de l'initialisation des variables x et y, nous avons créé à chaque fois un nouvel objet, et ces variables stockaient des références à différents objets. Et comme vous le savez, l'opérateur == compare les valeurs des variables, et les valeurs des variables de référence sont des références. Pour vérifier avec précision l'égalité entre deux variables entières, vous devez utiliser (aussi trivial que cela puisse paraître) la méthode égale. Réécrivons l'exemple ci-dessus :

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

System.out.println(a.equals(b)); // true
System.out.println(x.equals(y)); // true

Emballage et déballage automatiques

Qu’est-ce que l’emballage et le déballage automatiques ? Lors de la création de nouvelles variables entières, nous avons utilisé la construction suivante :

Integer a = 2020;

De cette façon, nous avons créé un nouvel objet sans utiliser le nouvel opérateur clé. Ceci est possible grâce au mécanisme d'autopacking de type primitif int. La procédure inverse se produit lors de l'affectation d'une variable int primitive à la valeur d'une variable de référence Integer :

Integer a = 2020;
int x = a;

Dans ce cas, il semble que nous ayons attribué une référence (à savoir, la référence à un objet est la valeur de la variable « a ») à une variable primitive. Mais en fait, grâce au mécanisme de décompression automatique, la valeur 2020 a été écrite dans la variable « x ». Le conditionnement/déballage automatique est un phénomène très courant en Java. Cela se produit souvent tout seul, parfois même à l’insu du programmeur. Mais encore faut-il connaître ce phénomène. Nous avons un article intéressant sur ce sujet sur Javarush .

Constantes de classe entière

La classe Integer fournit diverses constantes et méthodes pour travailler avec des entiers. Dans cette section, nous examinerons de plus près certains d’entre eux en pratique. Commençons par les constantes. Le tableau ci-dessous montre toutes les constantes de classe : Regardons les valeurs de toutes ces constantes en exécutant le code suivant :

public static void main(String[] args) {
        System.out.println(Integer.SIZE);
        System.out.println(Integer.BYTES);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.TYPE);
}

En conséquence, nous obtenons le résultat suivant :

32
4
2147483647
-2147483648
int

Méthodes de la classe Integer

Jetons maintenant un coup d'œil rapide aux méthodes les plus utilisées de la classe Integer. Ainsi, les « meilleurs » sont dirigés par des méthodes permettant de convertir un nombre à partir d'une chaîne ou de convertir une chaîne à partir d'un nombre. Commençons par convertir une chaîne en nombre. La méthode parseInt est utilisée à ces fins , la signature est ci-dessous :

• 
  static int parseInt(String s)

Cette méthode convertit String en int. Montrons comment fonctionne cette méthode :

int i = Integer.parseInt("10");
System.out.println(i); // 10

Si la conversion n'est pas possible (par exemple, nous avons transmis un mot à la méthode parseInt), une exception NumberFormatException sera levée. La méthode parseInt(String s) a un frère surchargé :

• 
  static int parseInt(String s, int radix)

Cette méthode convertit le paramètre s en int. Le paramètre radix indique dans quel système numérique le nombre en s a été initialement écrit, qui doit être converti en int. Exemples ci-dessous :

System.out.println(Integer.parseInt("0011", 2)); // 3
System.out.println(Integer.parseInt("10", 8));   // 8
System.out.println(Integer.parseInt("F", 16));   // 15

Les méthodes parseInt renvoient un type de données primitif int. Ces méthodes ont un analogue - la méthode valueOf . Certaines variantes de cette méthode appellent simplement parseInt en interne. La différence avec parseInt est que le résultat de valueOf sera un Integer, pas un int. Considérons ci-dessous toutes les options de cette méthode et un exemple de son fonctionnement :

• static Integer valueOf(int i) - renvoie un entier dont la valeur est i ;
• static Integer valueOf(String s) - similaire à parseInt(String s), mais le résultat sera Integer ;
• static Integer valueOf(String s, int radix) - similaire à parseInt(String s, int radix), mais le résultat sera Integer.

Exemples:

int a = 5;
Integer x = Integer.valueOf(a);
Integer y = Integer.valueOf("20");
Integer z = Integer.valueOf("20", 8);

System.out.println(x); // 5
System.out.println(y); // 20
System.out.println(z); // 16

Nous avons examiné les méthodes qui vous permettent de convertir String en int/Integer. La procédure inverse est réalisée à l'aide des méthodes toString . Vous pouvez appeler la méthode toString sur n'importe quel objet Integer et obtenir sa représentation sous forme de chaîne :

Integer x = 5;
System.out.println(x.toString()); // 5

Cependant, étant donné que la méthode toString est souvent appelée implicitement sur les objets (par exemple, lors de l'envoi d'un objet à la console pour impression), cette méthode est rarement utilisée explicitement par les développeurs. Il existe également une méthode statique toString, qui prend un paramètre int et le convertit en représentation sous forme de chaîne. Par exemple:

System.out.println(Integer.toString(5)); // 5

Cependant, comme pour la méthode toString non statique, l’utilisation explicite d’une méthode statique est rare. Plus intéressante est la méthode statique toString, qui prend 2 paramètres entiers :

• static String toString(int i, int radix) - convertira i en une représentation sous forme de chaîne dans le système numérique de base.

Exemple:

System.out.println(Integer.toString(5, 2)); // 101

La classe Integer dispose de plusieurs méthodes pour trouver le maximum/minimum de deux nombres :

• static int max(int ​​​​a, int b) renverra la plus grande valeur parmi les variables transmises ;
• static int min(int a, int b) renverra la plus petite valeur parmi les variables transmises.

Exemples:

int x = 4;
int y = 40;

System.out.println(Integer.max(x,y)); // 40
System.out.println(Integer.min(x,y)); // 4

Conclusion

Dans cet article, nous avons examiné la classe Integer. Nous avons parlé de quel type de classe il s'agit et de ce que sont les classes wrapper. Nous avons regardé la classe d'un point de vue pratique. Nous avons examiné des exemples d'opérations arithmétiques, y compris des opérations de comparaison. Nous avons examiné les subtilités de la comparaison de deux variables entières et examiné le concept d'objets mis en cache. Nous avons également mentionné le phénomène de compactage/décompression automatique des types de données primitifs. De plus, nous avons réussi à examiner certaines méthodes de la classe Integer, ainsi que certaines constantes. Ils ont donné des exemples de conversion de nombres d'un système numérique à un autre.

Devoirs

1. Étudiez quelles sont les autres méthodes de la classe Integer (vous pouvez les étudier sur le site avec la documentation officielle ), écrivez dans les commentaires laquelle des méthodes que vous avez étudiées (à l'exclusion de celles données dans l'article) est la plus utile à votre avis ( sera utilisé par vous le plus souvent). Et donnez également les raisons de votre opinion.

   PS Il n'y a pas de bonnes réponses ici, mais cette activité vous permettra de mieux étudier la classe.

2. Résolvez un petit problème simple pour consolider le matériel.

   Nous avons deux nombres :

   1100001001 - dans le système de nombres binaires
   33332 - dans le système de nombres quinaires

   Il est nécessaire, en utilisant uniquement les méthodes de la classe Integer, de déterminer le maximum parmi deux nombres donnés, puis d'afficher la différence entre la valeur maximale et la valeur minimale dans le système numérique ternaire.

3. Convertissez la valeur entière maximale possible en système de nombres octaux et affichez le nombre de chiffres dans le nombre obtenu (comptez le nombre par programme).