Типы-обертки детально

1. Класс Integer

Integer хорош еще и тем, что это класс, а значит, у него могут быть поля и методы. И, конечно, они у него есть. Даже много — несколько десятков. Поэтому мы рассмотрим самые основные из них.

У класса Integer есть два поля, которые содержат максимальное и минимальное значение типа int:

Integer.MAX_VALUE

Integer.MIN_VALUE

Иногда хочется присвоить переменной самое маленькое или самое большое значение типа int. Чтобы не загромождать код непонятными константами, можно очень красиво написать:

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(). Напомним, как он работает:

int имя = Integer.parseInt(строка);

Если в метод parseInt() передать строку, содержащую число (только цифры), он распарсит эту строку и вернет число, которое в ней содержится.

Остальные методы тоже полезны. Например, некоторые из них могут преобразовывать переданное число в строку в двоичном, восьмеричном или шестнадцатеричном виде.

2. Класс Double

Класс Double, в общем-то, аналогичен классу Integer, только является оберткой не для типа int, а для типа double. У него тоже есть интересные нам поля и методы, рассмотрим некоторые из них:

Интересных полей у класса 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 — положительную бесконечность. Тип double может не только делить на ноль, но и хранить такие значения.

Экспонента числа double

С экспонентой тоже все просто. Число double внутри состоит из мантисы и экспоненты. Только вот значение экспоненты — это не 10х, а 2х. Если экспонента вырастет на 1, итоговое значение числа станет больше в два раза.

MIN_EXPONENT == -1024, в итоге получаем 2-1024 примерно равно 10-308

Также у класса Double есть интересные методы:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Из интересного можно отметить наличие метода isInfinite(), который возвращает true, если переданное в него число было плюс или минус бесконечность.

Аналогично работает и метод 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. Отличия минимальны.

Ниже мы покажем упрощенный вариант класса 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

Работать с ними можно так же, как и с типом 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; // будет равен Boolean.TRUE
Boolean c = true; // будет равен Boolean.TRUE

a == b; // true (сравниваются как примитивы по значению)
a == c; // true (сравниваются как примитивы по значению)
b == c; // true (сравниваются по ссылке, но указывают на один и тот же объект)

Если очень нужно создать независимый объект Boolean, то надо создать его явно:

boolean a = true;
Boolean b = new Boolean(true); // новый объект Boolean
Boolean c = true; // будет равен Boolean.TRUE

a == b; // true (сравниваются как примитивы по значению)
a == c; // true (сравниваются как примитивы по значению)
b == c; // false (сравниваются по ссылке, указывают на различные объекты)

И еще один пример: использование Boolean внутри if:

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

Скомпилируется, но работать не будет:

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

5. Кэширование значений при autoboxing

А вот с целочисленными типами-обертками подводные камни есть.

Как вы уже знаете, если вы сравниваете int и Integer, Integer преобразовывается в int:

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

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

Если сравнить между собой два объекта типа Integer, преобразовываться к типу int они не будут:

Integer a = 500;
Integer b = 500;
int c = 500;

System.out.println(a == b); // сравнение ссылок
System.out.println(a == c);
System.out.println(b == c);

false
true
true

Хоть a == c и b == c, но a != b, т.к. при сравнении a и b сравниваются ссылки. Что, в принципе, ожидаемо.

Сюрприз

Но, вот если мы заменим 500 на 100, получим совсем другой результат:

Integer a = 100;
Integer b = 100;
int c = 100;

System.out.println(a == b); // сравнение ссылок
System.out.println(a == c);
System.out.println(b == c);

true
true
true

Все дело в том, что при autoboxing не всегда создается действительно новый объект Integer. Для значений от -128 до 127 включительно объекты кэшируются.

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

Если вы напишете Integer x = 128, autoboxing создаст новый объект, а если Integer x = 127, autoboxing возьмет готовый объект из кэша (из массива).

Если вы не хотите, чтобы объект Integer брался из кэша, вам придется создать его явно, написав: Integer x = new Integer(127);

Такой кэш есть у всех типов-оберток: Integer, Long, Byte, Short, Boolean. У типа Boolean оба его значения TRUE и FALSE являются константами: по сути тоже кэшируются.