Omslagsklasser i detalj

1. Integerklass

Integerär också bra genom att det är en klass, vilket betyder att den kan ha fält och metoder. Och naturligtvis har den dem. Många av dem - dussintals av dem. Här kommer vi att överväga de mest grundläggande.

Klassen Integerhar två fält som innehåller de högsta och lägsta möjliga värdena av inttypen:

Integer.MAX_VALUE

Integer.MIN_VALUE

Ibland vill man tilldela det minsta eller största möjliga intvärdet till en variabel. För att undvika att belamra din kod med obegripliga konstanter kan du skriva detta väldigt tydligt så här:

int min = Integer.MIN_VALUE;

min == 0x80000000

Klassen Integerhar också några intressanta metoder. Här är de:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

Du har tidigare stött på den statiska Integer.parseInt()metoden. Låt oss komma ihåg hur det fungerar:

int name = Integer.parseInt(string);

Om en sträng som innehåller ett nummer (endast siffror) skickas till parseInt()metoden, kommer den att analysera strängen och returnera numret den innehåller.

Resten av metoderna är också användbara. Till exempel kan några av dem konvertera ett passerat tal till en sträng som innehåller den binära, oktala eller hexadecimala representationen av talet.

2. Doubleklass

I allmänhet Doubleliknar klassen klassen Integer, bara den innehåller en doublesnarare än en int. Den har också områden och metoder som kommer att vara av intresse för oss. Tänk på några av dem:

Klassen Doublehar sex intressanta fält:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

Oändlighet

Om du dividerar -1.0med 0.0får du negativ oändlighet. Om du delar 1.0med 0.0får du positiv oändlighet. Du kan inte bara dividera a doublemed noll, utan du kan också använda den för att lagra resultatet av dessa operationer.

Exponent för adouble

Det är lätt att förstå exponenten. Internt består en dubbel av en mantissa och en exponent. Men här är värdet på exponenten inte , men . Således, om exponenten ökar med , kommer det totala värdet av talet att fördubblas.10x2x1

MIN_EXPONENT == -1024, vilket betyder , vilket är ungefär lika med2-102410-308

Och naturligtvis Doublehar klassen intressanta metoder:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Intressant nog finns det en isInfinite()metod som returnerar trueom det godkända talet är positivt eller negativt oändligt.

Metoden isNaN()är liknande — den kontrollerar om det godkända numret är NaN( Not-a-Number , en speciell konstant som indikerar ett odefinierat värde).

3. Characterklass

Klassen Characterär intressant främst för sitt stora antal statiska verktygsmetoder som låter dig kontrollera om tecken tillhör olika kategorier.

Exempel

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)

En egenskap hos dessa metoder är att de fungerar med alla kända alfabet: Arabiska siffror klassificeras som siffror, etc.

4. Booleanklass

Typen Booleanär praktiskt taget densamma som booleantypen. Skillnaderna är minimala.

Nedan visar vi en förenklad version av klassen Boolean:

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

Typen Booleanhar två konstanter (två fält):

Boolean.TRUE

true

Boolean.FALSE

false

Du kan arbeta med dem på samma sätt som du arbetar med booleantypen:

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)

Autoboxning fungerar utmärkt här. Det betyder att du kan använda den här typen på samma sätt som typen boolean- det finns inga fallgropar att se upp för.

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

Och här en jämförelse av booleanoch Booleantyperna:

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)

Om du verkligen behöver ett oberoende Booleanobjekt måste du skapa det uttryckligen:

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)

Ytterligare ett exempel, där vi använder Booleaninsidan av en if:

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

Detta kommer att kompileras, men det kommer inte att fungera!

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

5. Cachning av värden under autoboxning

Det finns några fallgropar relaterade till heltalsomslagstyper.

Som du redan vet, om vi jämför en intoch en , konverteras Integerden till en :Integerint

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

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

Om du jämför två Integerobjekt med varandra konverteras de inte till 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 == coch , men , för när vi jämför och vi jämför referenser. Vilket är i princip vad vi förväntar oss.b == ca != bab

Överraskning

Men om vi ersätter 500med 100får vi ett helt annat resultat:

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

Problemet här är att ett nytt Integerobjekt inte alltid skapas under autoboxning . Objekt cachelagras för värden -128genom 127inkluderande.

Klassen Integerhar en dold array som lagrar objekt: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Om du skriver Integer x = 128skapar autoboxningsprocessen ett nytt objekt, men om du skriver Integer x = 127hämtar autoboxningsprocessen det befintliga objektet från cachen (från arrayen).

Om du inte vill att Integerobjektet ska komma från cachen måste du skapa det uttryckligen genom att skriva:Integer x = new Integer(127);

Alla omslagstyper har en sådan cache: Integer, Long, Byte, Short, Boolean. För Booleantypen är dess TRUEoch FALSEvärden båda konstanter, så de är också i huvudsak cachade.