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:

Campo Descrizione
Integer.MAX_VALUE
Valore massimo possibile del inttipo
Integer.MIN_VALUE
Valore minimo possibile del inttipo

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:

Codice Descrizione
int min = Integer.MIN_VALUE;
min == 0x80000000

La Integerclasse ha anche alcuni metodi interessanti. Eccoli:

Metodi Descrizione
String Integer.toHexString(int)
Restituisce una stringa che è la rappresentazione esadecimale del numero
String Integer.toBinaryString(int)
Restituisce una stringa che è la rappresentazione binaria del numero
String Integer.toOctalString(int)
Restituisce una stringa che è la rappresentazione ottale del numero
Integer Integer.valueOf(int i)
Avvolge il passato intin un Integeroggetto
Integer Integer.parseInt(String)
Restituisce il numero ottenuto dalla stringa passata

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:

Campo Descrizione
double Double.NEGATIVE_INFINITY
Infinito negativo
double Double.POSITIVE_INFINITY
Infinito positivo
int Double.MIN_EXPONENT
Esponente minimo possibile (2 x )
int Double.MAX_EXPONENT
Esponente massimo possibile (2 x )
double Double.MIN_VALUE
Valore minimo possibile del doubletipo
double Double.MAX_VALUE
Valore massimo possibile del doubletipo

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:

Metodi Descrizione
String Double.toHexString(double)
Restituisce una stringa che è la rappresentazione esadecimale del numero
boolean Double.isInfinite(double)
Controlla se il numero passato è infinito.
boolean Double.isNaN(double)
Controlla se il numero passato èNaN
Double Double.valueOf(double)
Avvolge il passato doublein un Doubleoggetto
Double Double.parseDouble(String)
Restituisce il numero ottenuto dalla stringa passata

È 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

Metodi Descrizione
Character.isAlphabetic(int)
Controlla se un carattere è un carattere alfabetico
Character.isLetter(char)
Controlla se il carattere è una lettera
Character.isDigit(char)
Controlla se il carattere è una cifra
Character.isSpaceChar(char)
Controlla se il carattere è uno spazio, un'interruzione di riga o un'interruzione di pagina (codici: 12, 13, 14)
Character.isWhitespace(char)
Controlla se il carattere è uno spazio bianco: uno spazio, una tabulazione, ecc.
Character.isLowerCase(char)
Controlla se il carattere è minuscolo
Character.isUpperCase(char)
Controlla se il carattere è maiuscolo
Character.toLowerCase(char)
Converte il carattere in minuscolo
Character.toUpperCase(char)
Converte il carattere in maiuscolo

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:

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


Costanti: TRUEè Costruttore di classi FALSE


di variabili Il metodo restituisce il valore della variabile interna Questo metodo statico converte in e in .

Boolean








trueTRUEfalseFALSE

Il Booleantipo ha due costanti (due campi):

Costanti della classe Controparte per il tipo booleano Descrizione
Boolean.TRUE
true
VERO
Boolean.FALSE
false
falso

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

Codice Nota
if (Boolean.TRUE)
{
}
La Booleanclasse è l'unica classe che può essere scritta all'interno di una condizione
Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean с = true;
Tutte e tre le variabili sono uguali a true/TRUE
Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)
Le costanti possono essere confrontate usando entrambi equalse ==

Anche questo funzionerà.

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.

Come si scrive Come funziona
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:

Codice Nota
Boolean less = (2 < 3);
if (less)
{
   ...
}
Questo verrà compilato e funzionerà

Questo verrà compilato, ma non funzionerà!

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

Errore . Questa riga genererà un'eccezione


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:

Come si scrive Come funziona
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:

Codice Uscita 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 == 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:

Codice Uscita 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

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.