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

В этой статье мы рассмотрим с вами примитивные типы и литералы в Java. Типы в Java делятся на две категории: примитивные (простые, базовые) и ссылочные (объектные). Ссылочные типы - это массивы, классы и интерфейсы. 

В этом разделе мы рассмотрим только примитивные типы. Примитивы в Java предопределены заранее и поименованы ключевыми словами (keywords).

Примитивные типы можно разделить на следующие четыре группы:

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

2. Числа с плавающей точкой. Эта группа включает в себя типы данных flоаt и double, представляющие числа с точностью до определенного знака после десятичной точки.

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

4. Логические значения. Эта группа включает в себя тип данных boolean, специально предназначенный для представления логических значений.

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

Давайте начнём с целочисленных типов. Целочисленные числа представлены в языке Java четырьмя типами - byte, short, int и long. Первый вопрос, который все конечно же задают - зачем так много? Целочисленные типы различаются размером в байтах и конечно же возможными значениями. В зависимости от того, какие данные будут хранить ваш тип, вы выбираете одно из этих значений. 

byte — используется для передачи данных по сети, записи и чтения из файла. В математических операциях, как правило, не используется.

short — самый редко используемый тип в Java, может использоваться только в целях экономии памяти.

int — основной целочисленный тип, используемый в Java по умолчанию. Поэтому если вы не знаете какой тип вам выбрать, выбирайте смело int значение. Любое целое число будет рассматриваться компилятором как число типа int. Используется в качестве счётчика циклов, индексов массивов и индексов символов в строках.

long — целочисленный тип содержащий практически бесконечное количество значений. Используется в случаях, где числа превосходят 2 миллиарда и стандартного int уже не хватает. Используется в повседневной жизни для создания уникальных значений.

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

Давайте посмотрим на пример объявления и инициализации целочисленных примитивных типов:

byte b = 4;
short s1 = 7, s2 = 5;
int i1 = 56, i2;
i2 = 78;
long a1 = 456;

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

Целочисленные литералы бывают нескольких видов:

• десятичные 
• восьмеричные 
• шестнадцатеричные  
• двоичные - начиная с Java 7

Что это такое? Смотрите - существуют разные системы исчисления. 

Десятичные литералы

То есть, та система исчисления к которой мы привыкли - это десятичная. В ней мы используем 10 цифр для обозначения какого-то числа - от 0 до 9.

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

int x1 = 878;
int x2 = +878;
int x3 = -878;

Восьмеричные литералы

В восьмеричной системе исчисления используется восемь цифр: от 0 до 7. Для того чтобы обозначить, что это восьмеричная система исчисления, в начале такого значения ставится нолик. Например:

int six = 06; // Равно десятичному числу 6
int seven = 07; // Равно десятичному числу 7
int eight = 010; // Равно десятичному числу 8
int nine = 011; // Равно десятичному числу 9

System.out.println("eight: " + eight);
System.out.println("nine: " + nine);

Когда мы выводим на консоль такие значения, то они выводятся всегда в десятичном формате:

eight: 8
nine: 9

Шестнадцатеричные литералы

• Шестнадцатеричные литералы создаются используя следующие символы [0-9a-fA-F]
• Должны начинаться с 0x или 0X.
• Разрешается использовать до 16 символов в шестнадцатеричных числах, не учитывая префикс 0x и необязательный суффикс L.

Например:

int a1 = 0X0005;
int a2 = 0x7ddfffff;
int a3 = 0xcccccccc;

Двоичные литералы в Java 7

Для определения двоичного литерала, добавьте префикс 0b или 0B к числу. Используются числа 0 и 1. Например:

int i1 = 0b101;
int i2 = 0B101; 

Все целочисленные литералы представляют значения int. Если значение литерала лежит в диапазоне byte, short или char, то его можно присвоить переменной этого типа без приведения типов.

Для создания литерала типа long, необходимо явно указать компилятору, дополнив литерал буквой 'l' или 'L'. Но всё-таки лучше использовать большую L, потому что маленькая l очень похожа на единичку:

long a1 = 220433L;
long a2 = 0x3FFl;

Когда это может быть необходимо? Допустим, у вас есть какое-то большое число, которое не входит в диапазон int.

1.3. Подчеркивание в числовых литералах

Начиная с Java 7, добавлена возможность использовать любое количество символов подчеркивания для разделения групп цифр, что улучшает читабельность.

Подчеркивание может разделять только цифры! Нельзя использовать подчеркивания в следующих местах:

• В начале или конце числа
• Рядом с десятичной точкой в числе с плавающей точкой
• Перед 'F', 'f', 'l' или 'L' суффиксами
• Для разделения символов префиксов

int i1 = 12_567;            // OK
double d1 = 56.356_234;      // OK
short s = 0b000____0100;    // OK
int i2 = 220_;              // Ошибка компиляции
int i3 = 0_x2F;             // Ошибка компиляции
int i4 = 0x_3E;             // Ошибка компиляции
float f1 = 6345.56_f;       // Ошибка компиляции
float f2 = 3423_.87f;       // Ошибка компиляции

Дробные числа

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

double — это числа с двойной точностью, максимально приближённые к заданным или полученным в результате вычислений значениям. Используется в Java для любых математических вычислений (квадратный корень, синус, косинус).

float — менее точный тип с плавающей точкой. Используется реже с целью экономии памяти.

Давайте посмотрим на пример объявления примитивных типов с плавающей точкой. Всем литералам с плавающей точкой по умолчанию присваивается тип double. Для отделения дробной части используется точка, не запятая. Если целое число у вас ноль, то этот нолик можно опустить, можно просто написать .4:

double d1 = 145454545.676767676;
double d2 = .4;// число 0.4

Если вы хотите создать литерал типа float, нужно после литерала указать буковку F большую либо маленькую. В следующем примере создаются три переменные f1, f2, f3:

float f1 = 56.45455; // Ошибка компиляции
float f2 = 343434.454563F; 
float f3 = 78.45f;

Для переменной f1 не указана в конце F, а значит литерал имеет значение типа double. Поэтому в этой строке произойдёт ошибка компиляции. f2 и f3 указаны верно - в конце мы ставим в качестве префикса букву F.

Также для того, чтобы явно указать что наш литерал имеет значение double, мы можем в конце добавить символ D большой или маленький, но это не обязательно. Допустим, как это сделано в следующем примере для переменных d3 и d5:

double d3 = 454545.454545D; 
double d4 = 654.321; 
double d5 = 54.32d;

В языке Java есть три специальных числа плавающей точкой, которые используются для обозначения переполнения и ошибок:

• Положительная бесконечность - результат деления положительного числа на 0. Представлены константами Double.POSITIVE_INFINITY и Float.POSITIVE_INFINITY.
• Отрицательная бесконечность - результат деления отрицательного числа на 0. Представлены константами Double.NEGATIVE_INFINITY  и Float.NEGATIVE_INFINITY.
• NaN (не число) - вычисление 0/0 или извлечение квадратного корня из отрицательного числа. Представлены константами Double.NaN и Float.NAN.

Пример использования специальных чисел с плавающей точкой в арифметических выражениях:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        double b = 0.0;
        double c = -0.0;
        double g = Double.NEGATIVE_INFINITY;

        System.out.println(a / b);
        System.out.println(a / c);
        System.out.println(b == c);
        System.out.println(g * 0);
    }
}

Числа с плавающей точкой нельзя использовать в финансовых расчетах, где ошибки округления недопустимы. Например, в результате выполнения оператора System.out. println(2.0 - 1.1) будет выведено значение 0.8999999999999999, а не 0.9, как было бы логично предположить. Подобные ошибки связаны с внутренним двоичным представлением чисел. Как в десятичной системе счисления нельзя точно представить результат деления 1/3, так и в двоичной системе невозможно точно представить результат деления 1/10. Если же требуется исключить ошибки округления, то следует воспользоваться классом BigDecimal.

 

Следующая таблица содержит информацию о длине, диапазоне допустимых значений и значения по умолчанию примитивных типов: