Tipi di wrapper in dettaglio

1. Integerclasse

Integerè anche buono in quanto è una classe, il che significa che può avere campi e metodi. E, naturalmente, li ha. Molti di loro - dozzine di loro. Qui considereremo quelli più basilari.

La Integerclasse ha due campi che contengono i valori massimi e minimi possibili del inttipo:

Integer.MAX_VALUE

Integer.MIN_VALUE

A volte si desidera assegnare il intvalore più piccolo o più grande possibile a una variabile. Per evitare di ingombrare il tuo codice con costanti incomprensibili, puoi scriverlo molto chiaramente come segue:

int min = Integer.MIN_VALUE;

min == 0x80000000

La Integerclasse ha anche alcuni metodi interessanti. Eccoli:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

Hai già incontrato il Integer.parseInt()metodo statico. Ricordiamo come funziona:

int name = Integer.parseInt(string);

Se una stringa contenente un numero (solo cifre) viene passata al parseInt()metodo, analizzerà la stringa e restituirà il numero che contiene.

Anche il resto dei metodi è utile. Ad esempio, alcuni di essi possono convertire un numero passato in una stringa contenente la rappresentazione binaria, ottale o esadecimale del numero.

2. Doubleclasse

In generale, la Doubleclasse è simile alla Integerclasse, solo che esegue il wrapping di un file doublepiuttosto che di un file int. Ha anche campi e metodi che ci interesseranno. Considerane alcuni:

La Doubleclasse ha sei campi interessanti:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

Infinito

Se dividi -1.0per 0.0, ottieni infinito negativo. Se dividi 1.0per 0.0, ottieni infinito positivo. Non solo puoi dividere a doubleper zero, ma puoi anche usarlo per memorizzare il risultato di queste operazioni.

Esponente di adouble

Capire l'esponente è facile. Internamente, un doppio è costituito da una mantissa e un esponente. Ma qui il valore dell'esponente non è , ma . Pertanto, se l'esponente aumenta di , il valore totale del numero raddoppierà.10x2x1

MIN_EXPONENT == -1024, che significa , che è approssimativamente uguale a2-102410-308

E, naturalmente, la Doubleclasse ha metodi interessanti:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

È interessante notare che esiste un isInfinite()metodo che restituisce truese il numero passato è infinito positivo o negativo.

Il isNaN()metodo è simile: controlla se il numero passato è NaN( Not-a-Number , una costante speciale che indica un valore non definito).

3. Characterclasse

La Characterclasse è interessante principalmente per il suo gran numero di metodi di utilità statici che consentono di verificare se i caratteri appartengono a varie categorie.

Esempi

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)

Una caratteristica di questi metodi è che funzionano con tutti gli alfabeti conosciuti: i numeri arabi sono classificati come cifre, ecc.

4. Booleanclasse

Il Booleantipo è praticamente lo stesso del booleantipo. Le differenze sono minime.

Di seguito mostriamo una versione semplificata della 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);
   }
}

Il Booleantipo ha due costanti (due campi):

Boolean.TRUE

true

Boolean.FALSE

false

Puoi lavorare con loro nello stesso modo in cui lavori con il booleantipo:

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)

L'autoboxing funziona alla grande qui. Ciò significa che puoi utilizzare questo tipo allo stesso modo del booleantipo: non ci sono insidie ​​​​a cui prestare attenzione.

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

E qui un confronto tra i booleantipi e 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)

Se hai davvero bisogno di un Booleanoggetto indipendente, devi crearlo in modo esplicito:

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 altro esempio, in cui useremo a Booleaninside of an if:

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

Questo verrà compilato, ma non funzionerà!

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

5. Valori di memorizzazione nella cache durante l'autoboxing

Ci sono alcune insidie ​​​​correlate ai tipi di wrapper interi.

Come già sai, se confrontiamo an inte an Integer, Integerviene convertito in an int:

int a = 5;
Integer b = 5;
if (a == b)
{
   ...
}

int a = 5;
Integer b = Integer.valueOf(5);
if (a == b.intValue())
{
   ...
}

Se confronti due Integeroggetti tra loro, non vengono convertiti in 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 == ce , ma , perché quando confrontiamo e stiamo confrontando i riferimenti. Che è essenzialmente quello che ci aspetteremmo.b == ca != bab

Sorpresa

Ma se sostituiamo 500con 100, otteniamo un risultato completamente diverso:

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

Il problema qui è che un nuovo Integeroggetto non viene sempre effettivamente creato durante l'autoboxing . Gli oggetti vengono memorizzati nella cache per i valori -128tramite 127inclusivo.

La Integerclasse ha un array nascosto che memorizza gli oggetti: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Se scrivi Integer x = 128, il processo di autoboxing crea un nuovo oggetto, ma se scrivi Integer x = 127, il processo di autoboxing recupera l'oggetto esistente dalla cache (dall'array).

Se non vuoi che l' Integeroggetto provenga dalla cache, dovrai crearlo esplicitamente scrivendo:Integer x = new Integer(127);

Tutti i tipi di wrapper hanno una tale cache: Integer, Long, Byte, Short, Boolean. Per il Booleantipo, its TRUEe FALSEi valori sono entrambi costanti, quindi sono anche essenzialmente memorizzati nella cache.