H Примитивные типы в Java в черновиках Tutorial

Примитивные типы в Java — важная, часто используемая часть языка, которая требует особого обращения. В этой публикации попробуем ответить на все вопросы связанные с примитивными типами, механизмом их работы, обработкой. Статья предназначена как для новичков, которые только стали на тернистый путь изучения Java (к ним отношусь и я), так и для людей, достаточно знакомым с языком, которые смогут освежить знания и, надеюсь, найдут что-то интересное для себя.

---

Примитивные типы

Примитивные типы немного нарушают объектную ориентированность языка Java, так так представляют одиночные (простые) значения. Эта особенность объясняется желанием обеспечить максимальную эффективность. Создавать объект простой переменной с помощью new недостаточно эффективно, так как new перемещает объект в кучу. Вместо этого создается «автоматическая» переменная, которая не является ссылкой на объект. Переменная хранит единственное значение и располагается в стеке. Стек — это область хранения данных, расположена в RAM. Процессор имеет прямой доступ до этой области через указатель на стек, поэтому стек — очень быстрый и эффективный способ хранения данных. По скорости стек уступает только регистрам (логично, так как регистры расположены внутри процессора).
Все размеры примитивных типов строго фиксированы и не зависят от машинной архитектуры. Это одна с причин улучшенной переносимости Java-программ.
В Java определено восемь примитивных типов, которые можно разбить на четыре группы:

Целые числа	Числа с плавающей точкой	Символы	Логические значения
byte, short, int, long	float, double	char	boolean

Целые числа

Для целых чисел определены четыре примитивных типа: byte, short, int, long. Все эти типы представляют целочисленные значения со знаком: положительные или отрицательные. В Java нет положительных целочисленных значений без знака (unsigned). Как было сказано раньше, все размеры примитивных типов фиксированы:

Тип	Длина в байтах	Длина в битах	Диапазон
byte	1	8	[-128, 127] или [-27, 27-1]
short	2	16	[-32768, 32767] или [-215, 215-1]
int	4	32	[-2147483648, 2147483647] или [-231, 231-1]
long	8	64	[-9223372036854775808, 9223372036854775807] или [-263, 263-1]

Наименьшим целочисленным типом является byte. Переменные этого типа очень удобны для работы с потоками ввода-вывода и при манипулировании двоичными данными. Далее идет тип short, который применяется реже всех остальных типов. Наиболее часто употребляемым типом является int. Его постоянно используют в циклах, для индексации массивов. Может показаться, что использование типов byte и short в местах, где не требуется широкий диапазон значений, будет более эффективным чем использование int. Но это не так, потому что при вычислении выражений значения типа byte или short будут преобразованы в int (мы еще вернемся к этому вопросу). Когда длины типа int недостаточно для хранения значения, нужно использовать long. Его диапазон значений достаточно велик, что делает long удобным при работе с большими целыми числами.

Числа с плавающей точкой

Числа с плавающей точкой (или действительные числа) представлены типами float и double. Используются для хранения значений с точностью до определенного знака после десятичной точки.

Тип	Длина в байтах	Длина в битах	Диапазон
float	4	32	[1.4e-45, 3.4028235e38]
double	8	64	[4.9e-324, 1.7976931348623157308]

Тип float определяет числовое значение с плавающей точкой одинарной точности. Этот тип используется, когда нужно числовое значение с дробной частью, но без особой точности. Тип double используется для хранений значений с плавающей точкой двойной точности. Обработка значений двойной точности выполняется быстрее, чем обработка значений одинарной точности. Поэтому большинство математических функций класса java.lang.Math возвращают значения типа double. Эффективнее всего использовать double, когда требуется сохранить точность многократно повторяющихся вычислений или манипулировать большими числами.

Символы

В спецификации примитивный тип char принадлежит к целочисленным типам (или integral types), но поскольку он играет немного другую роль, можно выделить для него собственную категорию. Его роль — представлять символы Unicode. Для хранения символов требуется 16 бит. Странно, ведь для представления символов основных языков (например, английского, французского, испанского) достаточно 8 бит. Но такая цена интернационализации. Unicode использует полный набор международных символов на всех известных языках мира.

Тип	Длина в байтах	Длина в битах	Диапазон
char	2	16	['\u0000', '\uffff'] или [0, 65535]

Логические азначения

Примитивный тип boolean предназначен для хранения логических значений. Данный тип может принимать одно из двух возможных значений: true (истина) или false (ложь). Значения boolean возвращаются со всех логических операций (например, операции сравнения). Является обязательным при построении циклов, операторов (например, for, if).

Литералы

Значения примитивных типов данных в большинстве случаев инициализируются с помощью литералов. Рассмотрим их.

Целочисленные литералы

Наиболее часто используемые литералы. Любое целочисленное значение является числовым литералом (например, -10, 10 — десятичные значения). Можно использовать восьмеричные, шестнадцатеричные и двоичные литералы:

// десятичный литерал, числа [0, 9], не начинается с 0
int decimal = 10; // 10
// восьмеричный литерал начинается с 0, далее числа [0, 7]
int octal = 010; // 8
// шестнадцатеричный литерал начинается с 0x или 0Х, далее числа [0, 9] и символы [a-f]
int hexadecimal = 0x10; // 16
// двоичный литерал начинается с Оb или 0B, далее числа [0, 1]
int binary = 0b10; // 2

Все целочисленные литералы представляют значения int. Если значение литерала лежит в диапазоне byte, short или char, то его можно присвоить переменной этого типа без приведения типов. Для создания литерала типа long, необходимо явно указать компилятору, дополнив литерал буквой 'l' или 'L':

byte b1 = 127;
byte b2 = 128; // ошибка

short s1 = -32768;
short s2 = -32769; // ошибка

char c1 = 0;
char c2 = -1; // ошибка

long l1 = 10l;
long l2 = 0x7fffffffffffffffL; // максимальное значение типа long

Литералы с плавающей точкой

Существует две формы записи литеров с плавающей точкой: стандартная и экспоненциальная:

// стандартная форма
double d1 = 0.; // эквивалентно .0 или 0.0;
double d2 = 0.125;
// экспоненциальная форма - используется символ 'e' или 'E'
// после него степень числа 10, на которую следует умножить данное число
double d3 = 125E+10; // если степень положительная, '+' можно упустить
double d4 = 1.25e-10;

Всех литералам с плавающей точкой по-умолчанию присваивается тип double. Поэтому чтобы создать литерал типа float, нужно после литерала указать букву 'f' или 'F'. К литералам также можно добавлять букву 'd' или 'D', сообщая, что это литерал типа double, но зачем?

double d1 = 0.125;
float f2 = 0.125f;

Можно использовать шестнадцатеричные литералы с плавающей точкой, например:

// P - двоичный порядок, что обозначает степень числа 2, на которое следует умножить данное число
double d = 0x10.P10d; // конечно, можно и без 'd' 
float f = 0x20.P10f;

Для удобности чтения длинных литералов в 7 версии языка была добавлена возможность использовать символ '_' внутри литерала:

// можно делать любые комбинации с использованием любого количества символов '_'
int phone = 111__111__111;
int bin = 0b1000_1000_1000;
double dollars = 23_000.450__500;
// не допускается использовать символ '_' в конце или начале литерала, также не можно разрывать '0x' и '0b'

Символьные литералы

Символьные литералы заключаются в одинарные кавычки. Все отображаемые символы можно задавать таким способом. Если символ нельзя ввести непосредственно, используют управляющее последовательности начинающиеся с символа '\'. Хотя все эти последовательности можно заменить соответствующим Unicode кодом. Также символьный литерал можно создать используя восьмеричную ('\xxx') и шестнадцатеричную форму ('\uxxxx').

char h = 'a'; // стандартная  форма
char a = '\001'; // восьмеричная форма
char c = '\u0001'; // шестнадцатеричная форма 

Существуют также строковые литералы. Информацию о них можно получить тут.

Логические литералы

С логическими операторами все просто. Существует только два логических литерала:

boolean yes = true; // истина
boolean no = false; // ложь

Логические литералы можно присваивать только переменным типа boolean. Также важно понимать, что false не равен 0, а true не равен 1. Преобразовать переменную типа boolean в другие примитивные типы не выйдет.

Операции

Над целочисленными типами

• операторы сравнения (>, <, >=, <=) и равенства (==, !=)
• унарные операторы (+, -)
• мультипликативные (*, /, %) и аддитивные (+, -) операторы
• инкремент (++) и декремент (--) в префиксной и постфиксной формах
• знаковые (>>, <<) и без знаковые (>>>) операторы сдвига
• побитовые операторы (~, &, ^, |)
• условный оператор (? : )
• оператор приведения типов

Над Floating-Point типами

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

Над логическим типом

• операторы равенства (== и !=)
• логические операторы (!,&, |, ^)
• условные логические операторы (&&, ||)
• условный оператор (? : )

Преобразование

Существует три типа преобразований:

• расширяющее преобразование (widening)
• суживающее преобразование (narrowing)
• widening + narrowing (преобразование byte к char, сначала byte преобразовываем в int, а потом int — в char)

Расширяющее преобразование

Если оба типа совместимы и длина целевого типа больше длины исходного типа выполняется расширяющее преобразование (например byte преобразуется в int). Следующая таблица демонстрирует все возможные расширяющее преобразования. Курсовом помечены типы, преобразования в которые, возможно, приведут к потери данных.

byte	short, int, long, float, double
short	int, long, float, double
char	int, long, float, double
int	long, float, double
long	float, double
float	double (если использовать strictfp потери данных не будет)

Суживающее преобразование

При суживающем преобразовании возможна потеря информации об общей величине числового значения, также можно потерять точность и диапазон. Все возможные суживающее преобразования показаны в таблице:

short	byte, char
char	byte, short
int	byte, short, char
long	int, byte, short, char
float	long, int, byte, short, char
double	float, long, int, byte, short, char

Чтобы выполнить преобразование двух несовместимых типов необходимо воспользоваться приведением (casting). Если значения исходного целочисленного типа больше допустимого диапазона значений целевого типа, то оно будет сведено к результату деления по модулю на диапазон целевого типа. Если же значения типа с плавающей точкой приводится к значению целочисленного типа, то происходит усечение (отбрасывается дробная часть).

byte a = (byte)128; // - 128
byte b = (byte)42;  // привидение возможно, но, в данном случаи, в нем нет необходимости

int i1 = (int)1e20f; // 2147483647
int i2 = (int)Float.NaN; // 0

float f1 = (float)-1e100; // -Infinity
float f2 = (float)1e-50; // 0.0

Продвижение

Когда требуемая точность промежуточного значения выходит за пределы допустимого диапазона значений любого с операндов в выражении используется автоматическое продвижение типов.

int a = 100;
float b = 50.0f;
double c = 50.0;

double result = a - b + c; // 100.0
// на самом деле: result = (double)((float)a - b) + c;

Правила продвижения хорошо демонстрирует следующая диаграмма:

Классы-обертки

Для представления примитивных типов как объектов было сделаны классы-обертки (wrapper classes). Какие преимущества дают нам классы-обертки?

• возможность использования объектов классов-оберток в качестве параметров к методам или как generic-параметры
• возможность использования констант, которые отвечают за границы соответствующего типа данных (MIN_VALUE и MAX_VALUE)
• возможность использования методов для преобразования в другие примитивные типы, конвертации между системами счисления

Wrapper-классов восемь, по одному на каждый примитивный тип:

Примитивный тип	Класс-обертка
boolean	Boolean
byte	Byte
char	Character
float	Float
int	Integer
long	Long
short	Short
double	Double

Почти все классы (кроме Boolean и Character) унаследованы от абстрактного класса Number и являются сравнимыми (реализуют интерфейс Comparable). Иерархия, примерно, такая:

// существует несколько способов создания
Integer i1 = new Integer("10");
Integer i2 = new Integer(10);
Integer i3 = Integer.valueOf(10);
Integer i4 = Integer.valueOf("10", 10); // можно указать систему счисления, только для оберток целочисленных примитивных типов

Character c1 = new Character('c'); // тут только один способ

// получаем значения примитивных типов
int i5 = i1.intValue();
char c2 = c1.charValue();

Автоупаковка и распаковка

В версии JDK 5 были введены два важных средства:

• Автоупаковка (autoboxing) — процесс автоматического инкапсулирования примитивного типа в соответствующий класс-обертку. Отпадает необходимость явно создавать объект.
• Распаковка (unboxing) — процесс автоматического извлечения примитивного типа с соответствующего класса-обертки. Отпадает необходимость явного вызова метода для получения примитивного типа.

Эти средства облегчают создания объектов, получения примитивных типов, упрощают работу с коллекциями.

public static void main(String... s) {
    Integer i1 = 10; // автоупаковка  - Integer.valueOf(10)
    int i2 = i1; // распаковка  - i1.intValue()

    method(10); // автоупаковка в объект класса Integer - Integer.valueOf(10)

    ++i1; // распаковка - i1.intValue(), автоупаковка - Integer.valueOf(i1.intValue() + 1)
}

private static int method(Integer i) {
    return i; // распаковка объекта, принятого как параметр - i.intValue()
}

Некоторые полезные методы

Integer i1 = 128;
i1.compareTo(5); // 1, то есть i.intValue() > Integer.valueOf(5)

Integer.decode("0xabc"); // не работает с двоичными литералами
Integer.parseInt("10", 3); // работает с любой системой счисления [2, 36]

// метод преобразования
i1.byteValue(); // (byte)i.intValue()

// методы проверки
Float f = 20.5f;
Boolean badFloat = f.isInfinite() || f.isNaN(); // false, автоупаковка boolean

// преобразование в строку
f.toString();

Спасибо за внимание. Все дополнения, уточнения и критика приветствуются.

double a = computeSomething();
int b = (int)a;
double c = b/2.0;
// дальше работаем с "b" и "c", а с "a" не работаем

double lameDivide(double x, double y) {
    Double result = x * y;
    return result;
}