Types d'emballage en détail

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 :

Integer.MAX_VALUE

Integer.MIN_VALUE

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 :

int min = Integer.MIN_VALUE;

min == 0x80000000

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

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

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 :

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

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 :

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

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

Character.isAlphabetic(int)

Character.isLetter(char)

Character.isDigit(char)

Character.isSpaceChar(char)

Character.isWhitespace(char)

Character.isLowerCase(char)

Character.isUpperCase(char)

Character.toLowerCase(char)

Character.toUpperCase(char)

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 :

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);
   }
}

Le Booleantype a deux constantes (deux champs) :

Boolean.TRUE

true

Boolean.FALSE

false

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

if (Boolean.TRUE)
{
}

Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean c = true;

Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)

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.

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:

Boolean less = (2 < 3);
if (less)
{
   ...
}

Cela compilera, mais cela ne fonctionnera pas!

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

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:

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 :

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 :

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