«1. Обзор

Язык программирования Java имеет восемь примитивных типов данных.

В этой статье мы вспомним, что такое примитивы, и пройдемся по ним.

2. Примитивные типы данных

В Java определены восемь примитивов: int, byte, short, long, float, double, boolean и char — они не считаются объектами и представляют необработанные значения.

Они хранятся непосредственно в стеке (дополнительную информацию об управлении памятью в Java см. в этой статье).

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

Начнем с краткой справки:

Type Size (bits) Minimum Maximum Example
byte 8 -27 27– 1 byte b = 100;
short 16 -215 215– 1 short s = 30_000;
int 32 -231 231– 1 int i = 100_000_000;
long 64 -263 263– 1 long l = 100_000_000_000_000;
float 32 -2-149 (2-2-23)·2127 float f = 1.456f;
double 64 -2-1074 (2-2-52)·21023 double f = 1.456789012345678;
char 16 0 216– 1 char c = ‘c’;
boolean 1 – – boolean b = true;

2.1. int

Первый примитивный тип данных, который мы рассмотрим, — это int. Также известный как целое число, тип int содержит широкий диапазон значений не дробных чисел.

В частности, Java хранит его, используя 32 бита памяти. Другими словами, он может представлять значения от -2 147 483 648 (-231) до 2 147 483 647 (231-1).

В Java 8 можно хранить целое число без знака до 4 294 967 295 (232-1) с помощью новых специальных вспомогательных функций.

Мы можем просто объявить int просто: 

int x = 424_242;

int y;

Значение по умолчанию для int, объявленного без присваивания, равно 0.

Если переменная определена в методе, мы должны присвоить значение, прежде чем мы сможем используй это.

Мы можем выполнять все стандартные арифметические операции над целыми числами. Просто имейте в виду, что десятичные значения будут обрезаны при выполнении этих операций с целыми числами.

2.2. byte

byte — это примитивный тип данных, похожий на int, за исключением того, что он занимает всего 8 бит памяти. Итак, почему мы называем это байтом. Поскольку объем памяти очень мал, байт может содержать только значения от -128 (-27) до 127 (27 — 1).

Мы можем создать байт: 

byte b = 100;

byte empty;

Значение байта по умолчанию также равно 0.

2.3. short

Следующая остановка в нашем списке примитивных типов данных в Java короткая.

Если мы хотим сэкономить память, а байт слишком мал, мы можем использовать тип, промежуточный между двумя: короткий.

При 16 битах памяти это половина размера int и вдвое больше размера byte. Его диапазон возможных значений составляет от -32 768 (-215) до 32 767 (215 — 1).

short объявляется следующим образом: 

short s = 202_020;

short s;

Аналогично другим типам, значение по умолчанию равно 0. Мы также можем использовать для него все стандартные арифметические операции.

2.4. long

Наш последний примитивный тип данных, связанный с целыми числами, — long.

long — старший брат int. Он хранится в 64-битной памяти, поэтому может содержать значительно больший набор возможных значений.

Возможные значения long находятся в диапазоне от -9 223 372 036 854 775 808 (-263) до 9 223 372 036 854 775 807 (263 — 1).

Мы можем просто объявить один: 

long l = 1_234_567_890;

long l;

Как и в случае с другими целочисленными типами, значение по умолчанию также равно 0. Мы можем использовать всю арифметику для long, которая работает с int.

2.5. float

Мы представляем основные дробные числа в Java, используя тип float. Это десятичное число одинарной точности. Это означает, что если мы превысим шесть знаков после запятой, это число станет менее точным и больше приблизительным.

В большинстве случаев нас не волнует потеря точности. Но, если наш расчет требует абсолютной точности (т. е. финансовые операции, высадка на Луну и т. д.), нам нужно использовать специальные типы, предназначенные для этой работы. Для получения дополнительной информации ознакомьтесь с классом Java Big Decimal.

Этот тип хранится в 32-битной памяти, как и int. Однако из-за плавающей запятой его диапазон сильно отличается. Он может представлять как положительные, так и отрицательные числа. Наименьшее десятичное число — 1,40239846 x 10-45, а наибольшее значение — 3,40282347 x 1038.

Мы объявляем числа с плавающей запятой так же, как и любой другой тип: 

float f = 3.145f;

float f;

Значение по умолчанию — 0,0 вместо 0. Кроме того, обратите внимание, что мы добавляем обозначение f в конец литерала, чтобы определить число с плавающей запятой. В противном случае Java выдаст ошибку, поскольку тип десятичного значения по умолчанию — double.

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

2.6. двойной

«Далее мы смотрим на double — его название происходит от того факта, что это десятичное число с двойной точностью.

Он хранится в 64-битной памяти. Это означает, что он представляет гораздо больший диапазон возможных чисел, чем float.

Хотя он страдает тем же ограничением точности, что и float. Диапазон составляет от 4,9406564584124654 x 10-324 до 1,7976931348623157 x 10308. Этот диапазон также может быть положительным или отрицательным.

Объявление double аналогично другим числовым типам: 

double d = 3.13457599923384753929348D;

double d;

Значение по умолчанию также равно 0.0, как и для float. Подобно float, мы добавляем букву D, чтобы обозначить литерал как двойной.

2.7. boolean

Самый простой примитивный тип данных — логический. Он может содержать только два значения: true или false. Он хранит свое значение в одном бите.

Однако для удобства Java дополняет значение и сохраняет его в одном байте.

Объявите логическое значение следующим образом: 

boolean b = true;

boolean b;

Объявление его без значения по умолчанию равно false. boolean является краеугольным камнем управления потоком наших программ. Мы можем использовать над ними логические операторы (например, и, или и т. д.).

2.8. char

Последний примитивный тип данных, на который следует обратить внимание, это char.

Также называемый символом, char представляет собой 16-битное целое число, представляющее символ в кодировке Unicode. Его диапазон составляет от 0 до 65 535. Который в Unicode представляет собой от «\\u0000» до «\\uffff».

Список всех возможных значений Unicode можно найти на таких сайтах, как Unicode Table.

Давайте теперь объявим char: 

char c = 'a';

char c = 65;

char c;

При определении наших переменных мы можем использовать любой символьный литерал, и они будут автоматически преобразованы для нас в свою кодировку Unicode. Значение по умолчанию для символов — «/u0000».

2.9. Переполнение

Примитивные типы данных имеют ограничения по размеру. Но что произойдет, если мы попытаемся сохранить значение, превышающее максимальное значение?

Мы сталкиваемся с ситуацией, называемой переполнением.

Когда целое число переполняется, оно возвращается к минимальному значению и начинает отсчет оттуда.

Переполнение числа с плавающей запятой из-за возврата Infinity. Когда они переполняются, они возвращают 0.0.

Вот пример: 

int i = Integer.MAX_VALUE;
int j = i + 1;
// j will roll over to -2_147_483_648

double d = Double.MAX_VALUE;
double o = d + 1;
// o will be Infinity

Потеря памяти — это та же проблема, за исключением того, что мы сохраняем значение меньше минимального значения.

2.10. Автоупаковка

Каждый примитивный тип данных также имеет полную реализацию класса Java, которая может его обернуть. Например, класс Integer может обернуть int. Иногда возникает необходимость преобразовать примитивный тип в оболочку объекта (например, используя их с дженериками).

К счастью, Java может выполнить это преобразование автоматически. Мы называем этот процесс автобоксингом. Вот пример: 

Character c = 'c';

Integer i = 1;

3. Заключение

В этом руководстве мы рассмотрели восемь примитивных типов данных, поддерживаемых в Java.

Это стандартные блоки, используемые большинством, но не всеми Java-программами, поэтому стоит понять, как они работают.