Wrapper класове в детайли

1. Integerклас

Integerсъщо е добър с това, че е клас, което означава, че може да има полета и методи. И, разбира се, има ги. Много от тях - десетки от тях. Тук ще разгледаме най-основните.

Класът Integerима две полета, които съдържат максималните и минималните възможни стойности на intтипа:

Integer.MAX_VALUE

Integer.MIN_VALUE

Понякога искате да присвоите възможно най-малката or най-голямата intстойност на променлива. За да избегнете претрупването на codeа си с неразбираеми константи, можете да напишете това много ясно, Howто следва:

int min = Integer.MIN_VALUE;

min == 0x80000000

Класът Integerсъщо има някои интересни методи. Ето ги и тях:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

По-рано сте срещали статичния Integer.parseInt()метод. Нека си припомним How работи:

int name = Integer.parseInt(string);

Ако към метода бъде подаден низ, съдържащ число (само цифри) parseInt(), той ще анализира низа и ще върне числото, което съдържа.

Останалите методи също са полезни. Например, някои от тях могат да преобразуват предадено число в низ, съдържащ двоично, осмично or шестнадесетично представяне на числото.

2. Doubleклас

Като цяло Doubleкласът е подобен на Integerкласа, само че обвива a, doubleа не int. Освен това има области и методи, които ще ни интересуват. Помислете за няколко от тях:

Класът Doubleима шест интересни полета:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

безкрайност

Ако разделите -1.0на 0.0, получавате отрицателна безкрайност. Ако разделите 1.0на 0.0, получавате положителна безкрайност. Не само можете да разделите a doubleна нула, но можете също да го използвате за съхраняване на резултата от тези операции.

Показател на adouble

Разбирането на експонентата е лесно. Вътрешно двойното се състои от мантиса и експонента. Но тук стойността на степента не е , а . Така, ако експонентата се увеличи с , общата стойност на числото ще се удвои.10x2x1

MIN_EXPONENT == -1024, което означава , което е приблизително равно на2-102410-308

И разбира се, Doubleкласът има интересни методи:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Интересното е, че има isInfinite()метод, който връща true, ако предаденото число е положителна or отрицателна безкрайност.

Методът isNaN()е подобен — той проверява дали предаденото число е NaN( Not-a-Number , специална константа, която показва недефинирана стойност).

3. Characterклас

Класът Characterе интересен преди всичко с големия си брой статични полезни методи, които ви позволяват да проверите дали героите принадлежат към различни категории.

Примери

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)

Характеристика на тези методи е, че те работят с всички известни азбуки: арабските цифри се класифицират като цифри и т.н.

4. Booleanклас

Типът Booleanе почти същият като booleanтипа. Разликите са минимални.

По-долу показваме опростена version на 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);
   }
}

Типът Booleanима две константи (две полета):

Boolean.TRUE

true

Boolean.FALSE

false

Можете да работите с тях по същия начин, Howто работите с booleanтипа:

if (Boolean.TRUE)
{
}

Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean с = true;

Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)

Autoboxing работи чудесно тук. Това означава, че можете да използвате този тип по същия начин като типа boolean— няма клопки, за които да внимавате.

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

И ето сравнение на видовете booleanи 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)

Ако наистина имате нужда от независим Booleanобект, тогава трябва да го създадете изрично:

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)

Още един пример, където ще използваме Booleanвътрешност на if:

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

Това ще се компorра, но няма да работи!

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

5. Кеширане на стойности по време на autoboxing

Има някои клопки, свързани с типовете обвивки на цели числа.

Както вече знаете, ако сравним an intи an Integer, Integerсе преобразува в an int:

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

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

Ако сравните два Integerобекта един с друг, те не се преобразуват в 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и , но , защото когато сравняваме и сравняваме препратки. Което по същество е това, което бихме очаквали.b == ca != bab

Изненада

Но ако заменим 500с 100, получаваме напълно различен резултат:

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

Проблемът тук е, че нов Integerобект не винаги се създава по време на автоматичното поставяне в кутия . Обектите се кешират за стойности -128чрез 127включително.

Класът Integerима скрит масив, който съхранява обекти: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Ако напишете Integer x = 128, тогава процесът на автоматично поставяне в кутия създава нов обект, но ако напишете Integer x = 127, тогава процесът на автоматично поставяне в кутия извлича съществуващия обект от кеша (от масива).

Ако не искате Integerобектът да идва от кеша, ще трябва да го създадете изрично, като напишете:Integer x = new Integer(127);

Всички типове обвивки имат такъв кеш: Integer, Long, Byte, Short, Boolean. За Booleanтипа стойностите му TRUEи FALSEса константи, така че те също са по същество кеширани.