Wrapperklassen in detail

1. Integerklasse

Integeris ook goed omdat het een klasse is, wat betekent dat het velden en methoden kan hebben. En natuurlijk heeft het ze. Veel van hen - tientallen van hen. Hier zullen we de meest elementaire bekijken.

De Integerklasse heeft twee velden die de maximaal en minimaal mogelijke waarden van het inttype bevatten:

Integer.MAX_VALUE

Integer.MIN_VALUE

Soms wil je de kleinst of grootst mogelijke waarde toekennen intaan een variabele. Om te voorkomen dat uw code volloopt met onbegrijpelijke constanten, kunt u dit als volgt heel duidelijk schrijven:

int min = Integer.MIN_VALUE;

min == 0x80000000

De Integerklas heeft ook een aantal interessante methoden. Daar zijn ze:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

U bent eerder de statische Integer.parseInt()methode tegengekomen. Laten we onthouden hoe het werkt:

int name = Integer.parseInt(string);

Als een tekenreeks met een getal (alleen cijfers) aan de parseInt()methode wordt doorgegeven, zal deze de tekenreeks ontleden en het getal dat het bevat retourneren.

De rest van de methoden zijn ook nuttig. Sommigen van hen kunnen bijvoorbeeld een doorgegeven getal converteren naar een tekenreeks die de binaire, octale of hexadecimale weergave van het getal bevat.

2. Doubleklasse

Over het algemeen is de Doubleklasse vergelijkbaar met de Integerklasse, alleen wordt er een doublein plaats van een int. Het heeft ook velden en methoden die voor ons interessant zullen zijn. Overweeg er een paar:

De Doubleklas heeft zes interessante velden:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

Oneindigheid

Als je deelt -1.0door 0.0, krijg je negatief oneindig. Als je deelt 1.0door 0.0, krijg je positief oneindig. U kunt niet alleen a doubledoor nul delen, maar u kunt er ook het resultaat van deze bewerkingen in opslaan.

Exponent van eendouble

Het begrijpen van de exponent is eenvoudig. Intern bestaat een dubbel uit een mantisse en een exponent. Maar hier is de waarde van de exponent niet , maar . Dus als de exponent toeneemt met , zal de totale waarde van het getal verdubbelen.10x2x1

MIN_EXPONENT == -1024, wat betekent , wat ongeveer gelijk is aan2-102410-308

En natuurlijk Doubleheeft de klas interessante methoden:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Interessant is dat er een isInfinite()methode is die terugkeert trueals het doorgegeven getal positief of negatief oneindig is.

De isNaN()methode is vergelijkbaar: er wordt gecontroleerd of het doorgegeven getal NaN( Not-a-Number , een speciale constante die een ongedefinieerde waarde aangeeft) is.

3. Characterklasse

De Characterklasse is vooral interessant vanwege het grote aantal statische hulpprogramma's waarmee u kunt controleren of tekens tot verschillende categorieën behoren.

Voorbeelden

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)

Een kenmerk van deze methoden is dat ze werken met alle bekende alfabetten: Arabische cijfers worden geclassificeerd als cijfers, enz.

4. Booleanklasse

Het Booleantype is vrijwel hetzelfde als het booleantype. De verschillen zijn minimaal.

Hieronder laten we een vereenvoudigde versie van de Booleanklasse zien:

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

Het Booleantype heeft twee constanten (twee velden):

Boolean.TRUE

true

Boolean.FALSE

false

U kunt ermee werken op dezelfde manier als met het 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)

Autoboxen werkt hier prima. Dat betekent dat je dit type op dezelfde manier kunt gebruiken als het booleantype — er zijn geen valkuilen waar je op moet letten.

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

En hier een vergelijking van de booleanen Booleantypes:

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)

Als u echt een onafhankelijk Booleanobject nodig heeft, moet u dit expliciet maken:

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)

BooleanNog een voorbeeld, waarbij we een binnenkant van een gebruiken if:

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

Dit zal compileren, maar het zal niet werken!

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

5. Waarden cachen tijdens autoboxen

Er zijn enkele valkuilen met betrekking tot integer-wrappertypen.

Zoals je al weet, als we an inten an vergelijken Integer, Integerwordt de geconverteerd naar een int:

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

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

Als je twee Integerobjecten met elkaar vergelijkt, worden ze niet omgezet naar 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 == cen , maar , omdat wanneer we vergelijken en we referenties vergelijken. Dat is in wezen wat we zouden verwachten.b == ca != bab

Verrassing

Maar als we vervangen 500door 100, dan krijgen we een heel ander resultaat:

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

Het probleem hier is dat er niet altijd een nieuw Integerobject wordt gemaakt tijdens het autoboxen . Objecten worden in de cache opgeslagen voor waarden -128tot en met 127inclusief.

De Integerklasse heeft een verborgen array waarin objecten worden opgeslagen: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Als u schrijft Integer x = 128, maakt het autoboxing-proces een nieuw object aan, maar als u schrijft Integer x = 127, haalt het autoboxing-proces het bestaande object uit de cache (uit de array).

Als u niet wilt dat het Integerobject uit de cache komt, moet u het expliciet maken door te schrijven:Integer x = new Integer(127);

Alle wrappertypes hebben zo'n cache: Integer, Long, Byte, Short, Boolean. Voor het Booleantype zijn zijn TRUEen FALSEwaarden beide constanten, dus ze worden ook in wezen in de cache opgeslagen.