1. Integerclasse

Integerest également bon en ce sens qu'il s'agit d'une classe, ce qui signifie qu'il peut avoir des champs et des méthodes. Et, bien sûr, il les a. Beaucoup d'entre eux - des dizaines d'entre eux. Ici, nous allons considérer les plus basiques.

La Integerclasse a deux champs qui contiennent les valeurs maximales et minimales possibles du inttype :

Champ Description
Integer.MAX_VALUE
Valeur maximale possible du inttype
Integer.MIN_VALUE
Valeur minimale possible du inttype

Parfois, vous souhaitez affecter la intvaleur la plus petite ou la plus grande possible à une variable. Pour éviter d'encombrer votre code avec des constantes incompréhensibles, vous pouvez écrire ceci très clairement comme suit :

Code Description
int min = Integer.MIN_VALUE;
min == 0x80000000

La Integerclasse a également quelques méthodes intéressantes. Les voici:

Méthodes Description
String Integer.toHexString(int)
Renvoie une chaîne qui est la représentation hexadécimale du nombre
String Integer.toBinaryString(int)
Renvoie une chaîne qui est la représentation binaire du nombre
String Integer.toOctalString(int)
Renvoie une chaîne qui est la représentation octale du nombre
Integer Integer.valueOf(int i)
Enveloppe le passé intdans un Integerobjet
Integer Integer.parseInt(String)
Renvoie le nombre obtenu à partir de la chaîne passée

Vous avez déjà rencontré la Integer.parseInt()méthode statique. Rappelons comment cela fonctionne :

int name = Integer.parseInt(string);

Si une chaîne contenant un nombre (uniquement des chiffres) est transmise à la parseInt()méthode, elle analysera la chaîne et renverra le nombre qu'elle contient.

Les autres méthodes sont également utiles. Par exemple, certains d'entre eux peuvent convertir un nombre transmis en une chaîne contenant la représentation binaire, octale ou hexadécimale du nombre.



2. Doubleclasse

En général, la Doubleclasse est similaire à la Integerclasse, sauf qu'elle enveloppe un doubleplutôt qu'un int. Il a aussi des domaines et des méthodes qui vont nous intéresser. Considérez-en quelques-uns :

La Doubleclasse a six champs intéressants :

Champ Description
double Double.NEGATIVE_INFINITY
Infini négatif
double Double.POSITIVE_INFINITY
Infini positif
int Double.MIN_EXPONENT
Exposant minimum possible (2 x )
int Double.MAX_EXPONENT
Exposant maximum possible (2 x )
double Double.MIN_VALUE
Valeur minimale possible du doubletype
double Double.MAX_VALUE
Valeur maximale possible du doubletype

Infini

Si vous divisez -1.0par 0.0, vous obtenez moins l'infini. Si vous divisez 1.0par 0.0, vous obtenez l'infini positif. Non seulement vous pouvez diviser a doublepar zéro, mais vous pouvez également l'utiliser pour stocker le résultat de ces opérations.

Exposant d'undouble

Comprendre l'exposant est facile. En interne, un double se compose d'une mantisse et d'un exposant. Mais ici la valeur de l'exposant n'est pas , mais . Ainsi, si l'exposant augmente de , la valeur totale du nombre doublera.10x2x1

MIN_EXPONENT == -1024, ce qui signifie , qui est approximativement égal à2-102410-308

Et bien sûr, la Doubleclasse a des méthodes intéressantes :

Méthodes Description
String Double.toHexString(double)
Renvoie une chaîne qui est la représentation hexadécimale du nombre
boolean Double.isInfinite(double)
Vérifie si le nombre passé est infini.
boolean Double.isNaN(double)
Vérifie si le numéro transmis estNaN
Double Double.valueOf(double)
Enveloppe le passé doubledans un Doubleobjet
Double Double.parseDouble(String)
Renvoie le nombre obtenu à partir de la chaîne passée

Fait intéressant, il existe une isInfinite()méthode qui renvoie truesi le nombre passé est l'infini positif ou négatif.

La isNaN()méthode est similaire — elle vérifie si le nombre passé est NaN( Not-a-Number , une constante spéciale qui indique une valeur indéfinie).



3. Characterclasse

La Characterclasse est intéressante principalement pour son grand nombre de méthodes utilitaires statiques qui permettent de vérifier si les caractères appartiennent à différentes catégories.

Exemples

Méthodes Description
Character.isAlphabetic(int)
Vérifie si un caractère est un caractère alphabétique
Character.isLetter(char)
Vérifie si le caractère est une lettre
Character.isDigit(char)
Vérifie si le caractère est un chiffre
Character.isSpaceChar(char)
Vérifie si le caractère est un espace, un saut de ligne ou un saut de page (codes : 12, 13, 14)
Character.isWhitespace(char)
Vérifie si le caractère est un espace : un espace, une tabulation, etc.
Character.isLowerCase(char)
Vérifie si le caractère est en minuscule
Character.isUpperCase(char)
Vérifie si le caractère est en majuscule
Character.toLowerCase(char)
Convertit le caractère en minuscule
Character.toUpperCase(char)
Convertit le caractère en majuscule

Une caractéristique de ces méthodes est qu'elles fonctionnent avec tous les alphabets connus : les chiffres arabes sont classés comme des chiffres, etc.



4. Booleanclasse

Le Booleantype est pratiquement le même que le booleantype. Les différences sont minimes.

Ci-dessous, nous montrons une version simplifiée de la Booleanclasse :

Code Description
class Boolean
{
   public static final Boolean TRUE = new Boolean(true);
   public static final Boolean FALSE = new Boolean(false);

   private final boolean value;

   public Boolean(boolean value)
   {
      this.value = value;
   }

   public boolean booleanValue()
   {
      return value;
   }

   public static Boolean valueOf(boolean value)
   {
      return (value ? TRUE : FALSE);
   }
}


Constantes : TRUEè Constructeur de classe FALSE


de variables La méthode renvoie la valeur de la variable interne Cette méthode statique convertit en et en .

Boolean








trueTRUEfalseFALSE

Le Booleantype a deux constantes (deux champs) :

Constantes de la classe Contrepartie pour le type booléen Description
Boolean.TRUE
true
vrai
Boolean.FALSE
false
FAUX

Vous pouvez les utiliser de la même manière que vous travaillez avec le booleantype :

Code Note
if (Boolean.TRUE)
{
}
La Booleanclasse est la seule classe qui peut être écrite à l'intérieur d'une condition
Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean c = true;
Les trois variables sont égales à true/TRUE
Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)
Les constantes peuvent être comparées en utilisant à la fois equalset ==

Cela fonctionnera également.

La boxe automatique fonctionne très bien ici. Cela signifie que vous pouvez utiliser ce type de la même manière que le booleantype - il n'y a pas de pièges à éviter.

Comment c'est écrit Comment ça fonctionne
Boolean a = true;
Boolean b = true;
Boolean c = false;
boolean d = a;
Boolean a = Boolean.valueOf(true);
Boolean b = Boolean.valueOf(true);
Boolean c = Boolean.valueOf(false);
boolean d = a.booleanValue();

Et voici une comparaison des types booleanet Boolean:

boolean a = true;
Boolean b = true; // b will be equal to Boolean.TRUE
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // true (compared by reference, but they point to the same object)

Si vous avez vraiment besoin d'un Booleanobjet indépendant, vous devez le créer explicitement :

boolean a = true;
Boolean b = new Boolean(true); // New Boolean object
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // false (compared by reference, and they point to different objects)

Un autre exemple, où nous utiliserons a Booleaninside of an if:

Code Note
Boolean less = (2 < 3);
if (less)
{
   ...
}
Cela compilera et fonctionnera

Cela compilera, mais cela ne fonctionnera pas!

Code Note
Boolean less = null;
if (less)
{
   ...
}

Erreur . Cette ligne lèvera une exception


5. Mise en cache des valeurs pendant l'autoboxing

Il existe certains pièges liés aux types de wrapper entiers.

Comme vous le savez déjà, si nous comparons an intet an Integer, le Integerest converti en an int:

Comment c'est écrit Comment ça fonctionne
int a = 5;
Integer b = 5;
if (a == b)
{
   ...
}
int a = 5;
Integer b = Integer.valueOf(5);
if (a == b.intValue())
{
   ...
}

Si vous comparez deux Integerobjets entre eux, ils ne sont pas convertis en ints :

Code Sortie console
Integer a = 500;
Integer b = 500;
int c = 500;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);




false
true
true

a == cet , mais , parce que quand on compare et on compare des références. C'est essentiellement ce à quoi nous nous attendions.b == ca != bab

Surprendre

Mais si nous remplaçons 500par 100, nous obtenons un résultat complètement différent :

Code Sortie console
Integer a = 100;
Integer b = 100;
int c = 100;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);




true
true
true

Le problème ici est qu'un nouvel Integerobjet n'est pas toujours créé lors de l'autoboxing . Les objets sont mis en cache pour les valeurs -128via 127inclusive.

La Integerclasse a un tableau caché qui stocke les objets : Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Si vous écrivez Integer x = 128, le processus d'autoboxing crée un nouvel objet, mais si vous écrivez Integer x = 127, alors le processus d'autoboxing récupère l'objet existant du cache (du tableau).

Si vous ne voulez pas que l' Integerobjet provienne du cache, vous devrez le créer explicitement en écrivant :Integer x = new Integer(127);

Tous les types de wrapper ont un tel cache : Integer, Long, Byte, Short, Boolean. Pour le Booleantype, ses valeurs TRUEet sont des constantes, elles sont donc également essentiellement mises en cache.FALSE