Clasele de wrapper în detaliu

1. Integerclasa

Integereste bun și prin faptul că este o clasă, ceea ce înseamnă că poate avea câmpuri și metode. Și, desigur, le are. Mulți dintre ei - zeci de ei. Aici le vom lua în considerare pe cele mai de bază.

Clasa Integerare două câmpuri care conțin valorile maxime și minime posibile ale inttipului:

Integer.MAX_VALUE

Integer.MIN_VALUE

Uneori doriți să atribuiți cea mai mică sau mai mare intvaloare posibilă unei variabile. Pentru a evita aglomerarea codului cu constante de neînțeles, puteți scrie acest lucru foarte clar, după cum urmează:

int min = Integer.MIN_VALUE;

min == 0x80000000

Clasa Integerare și câteva metode interesante. Aici sunt ei:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

Ați întâlnit anterior metoda statică Integer.parseInt(). Să ne amintim cum funcționează:

int name = Integer.parseInt(string);

Dacă un șir care conține un număr (doar cifre) este transmis metodei parseInt(), aceasta va analiza șirul și va returna numărul pe care îl conține.

Restul metodelor sunt de asemenea utile. De exemplu, unele dintre ele pot converti un număr transmis într-un șir care conține reprezentarea binară, octală sau hexazecimală a numărului.

2. Doubleclasa

În general, Doubleclasa este similară cu Integerclasa, doar că include un doublemai degrabă decât un int. Are și domenii și metode care ne vor interesa. Luați în considerare câteva dintre ele:

Clasa Doubleare șase domenii interesante:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

Infinit

Dacă împărțiți -1.0cu 0.0, obțineți infinit negativ. Dacă împărțiți 1.0cu 0.0, obțineți infinit pozitiv. Nu numai că puteți împărți a doublela zero, dar îl puteți folosi și pentru a stoca rezultatul acestor operații.

Exponent al adouble

Înțelegerea exponentului este ușoară. În interior, un dublu este format dintr-o mantisă și un exponent. Dar aici valoarea exponentului nu este , ci . Astfel, dacă exponentul crește cu , valoarea totală a numărului se va dubla.10x2x1

MIN_EXPONENT == -1024, ceea ce înseamnă , care este aproximativ egal cu2-102410-308

Și, desigur, Doubleclasa are metode interesante:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Interesant este că există o isInfinite()metodă care revine truedacă numărul trecut este infinit pozitiv sau negativ.

Metoda isNaN()este similară — verifică dacă numărul transmis este NaN( Not-a-Number , o constantă specială care indică o valoare nedefinită).

3. Characterclasa

Clasa Charactereste interesantă în primul rând pentru numărul mare de metode utilitare statice care vă permit să verificați dacă caracterele aparțin diferitelor categorii.

Exemple

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)

O caracteristică a acestor metode este că funcționează cu toate alfabetele cunoscute: cifrele arabe sunt clasificate ca cifre etc.

4. Booleanclasa

Tipul Booleaneste practic același cu booleantipul. Diferentele sunt minime.

Mai jos arătăm o versiune simplificată a Booleanclasei:

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

Tipul Booleanare două constante (două câmpuri):

Boolean.TRUE

true

Boolean.FALSE

false

Puteți lucra cu ele în același mod în care lucrați cu booleantipul:

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)

Autoboxing-ul funcționează excelent aici. Aceasta înseamnă că puteți utiliza acest tip în același mod ca booleantipul - nu există capcane la care să aveți grijă.

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

Și aici o comparație a tipurilor booleanși 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)

Dacă într-adevăr aveți nevoie de un Booleanobiect independent, atunci trebuie să îl creați în mod explicit:

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)

Încă un exemplu, în care vom folosi Booleaninteriorul unui if:

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

Aceasta se va compila, dar nu va funcționa!

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

5. Memorarea în cache a valorilor în timpul autoboxingului

Există câteva capcane legate de tipurile de pachete întregi.

După cum știți deja, dacă comparăm an intși an Integer, Integereste convertit într-un int:

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

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

Dacă comparați două Integerobiecte între ele, acestea nu sunt convertite în 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 == cși , dar , pentru că atunci când comparăm și comparăm referințe. Ceea ce este în esență ceea ce ne-am aștepta.b == ca != bab

Surprinde

Dar dacă înlocuim 500cu 100, atunci obținem un rezultat complet diferit:

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

Problema aici este că un obiect nou nu este întotdeauna creat efectiv în timpul autoboxinguluiInteger . Obiectele sunt stocate în cache pentru valori -128prin 127inclusiv.

Clasa Integerare o matrice ascunsă care stochează obiecte: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Dacă scrieți Integer x = 128, atunci procesul de autoboxing creează un obiect nou, dar dacă scrieți Integer x = 127, atunci procesul de autoboxing preia obiectul existent din cache (din matrice).

Dacă nu doriți ca Integerobiectul să provină din cache, va trebui să-l creați explicit scriind:Integer x = new Integer(127);

Toate tipurile de wrapper au un astfel de cache: Integer, Long, Byte, Short, Boolean. Pentru Booleantip, valorile sale TRUEși FALSEvalorile sunt ambele constante, deci sunt, de asemenea, în esență stocate în cache.