Типы данных в Java: примитивы, ссылочные типы и значения по умолчанию

Два семейства: примитивы и ссылки

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

Это различие важно, потому что примитивы лёгкие и копируются по значению, тогда как ссылочные переменные указывают на общие объекты. Начните с восьми примитивов - это фундамент, на котором строится всё остальное.

Восемь примитивных типов

В Java ровно восемь встроенных примитивных типов. Шесть - числа, один - символ, один - логический:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // 8-битное целое,  -128 .. 127
        short  s = 30000;        // 16-битное целое
        int    i = 2_000_000;    // 32-битное целое (тип по умолчанию для целых чисел)
        long   big = 9_000_000_000L; // 64-битное целое - обратите внимание на L

        float  f = 3.14f;        // 32-битное вещественное - обратите внимание на f
        double d = 3.141592653589793; // 64-битное вещественное (тип по умолчанию для дробных чисел)

        char   c = 'A';          // один 16-битный символ Unicode
        boolean flag = true;     // только true или false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

На что стоит обратить внимание сразу: подчёркивания в 2_000_000 - это всего лишь визуальные разделители, которые компилятор игнорирует; суффиксы L и f обязательны (подробнее ниже); а char использует одинарные кавычки, тогда как String использовал бы двойные.

Выбор числового типа

byte или short вам почти никогда не нужны - они экономят память только в огромных массивах. Настоящий выбор делается между int/long для целых чисел и float/double для дробных.

Тип	Размер	Использовать, когда
int	32 бита	Тип по умолчанию для целых чисел (до ~2,1 миллиарда)
long	64 бита	Значения свыше ~2 миллиардов: метки времени в миллисекундах, размеры файлов
double	64 бита	Тип по умолчанию для дробных - хорошая точность
float	32 бита	Только когда памяти мало и точностью можно пожертвовать

Ловушка - это переполнение. int молча зацикливается, когда выходит за пределы диапазона: никакой ошибки, просто неверный ответ:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // переполняется в отрицательное число!

        long safe = (long) maxInt + 1;  // сначала повышаем до long
        System.out.println(safe);
    }
}

maxInt + 1 переполняется до -2147483648, потому что оба операнда - int, и результат остаётся int. Если сначала привести одну сторону к long, вычисление выполнится в 64 битах. Когда значение может быть большим - особенно миллисекунды с 1970 года - берите long.

Литералы и их суффиксы

У «голого» числового литерала есть тип по умолчанию, и это многих подводит. 100 - это int; 3.14 - это double. Чтобы записать литерал long или float, нужно добавить суффикс:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // без L это слишком велико для int -> ошибка
        float ratio = 0.5f;               // без f правая часть - double -> ошибка
        double pi = 3.14;                 // нормально - дробные по умолчанию double

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Уберите L из 8_000_000_000L, и код не скомпилируется, потому что литерал превышает диапазон int ещё до того, как попадёт в переменную long. Уберите f из 0.5f, и Java пожалуется, что double нельзя присвоить float без приведения. Суффикс нечувствителен к регистру, но используйте заглавную L - строчная l выглядит ровно как цифра 1.

char - это число под маской

char хранит 16-битную кодовую единицу Unicode, а значит, он одновременно работает как небольшое беззнаковое целое. С ним можно выполнять арифметику и преобразовывать туда-обратно с помощью приведения:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - значение 'A' в Unicode
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

Иногда это удобно для сдвига букв, но не полагайтесь на это для работы с текстом - для этого есть String. Обратите внимание: char использует одинарные кавычки ('A'); двойные кавычки ("A") создают String из одного символа, а это совершенно другой тип.

Значения по умолчанию (и подвох с локальными переменными)

Поля и элементы массивов, которые вы не инициализируете, получают разумное значение по умолчанию. Но это касается только полей и ячеек массивов: локальные переменные не получают никакого значения по умолчанию, и использовать такую до присвоения значения - это ошибка компиляции, а не сюрприз во время выполнения.

public class Main {
    static int counter;        // поле -> по умолчанию 0
    static boolean ready;      // поле -> по умолчанию false
    static String name;        // поле -> по умолчанию null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // элементы массива по умолчанию равны 0
        System.out.println(nums[0]); // 0
    }
}

Если бы вы вместо этого написали int x; System.out.println(x); внутри main, компилятор отклонил бы это с сообщением «variable x might not have been initialized». Эта строгость - преимущество: она не даёт вам прочитать мусор. Значения по умолчанию, которые стоит запомнить: числовые типы 0, boolean false, char ' ' и любой ссылочный тип null.

Далее: Strings

String - это ссылочный тип, с которым вы будете иметь дело чаще всего: текст, объединённые значения, ввод пользователя. Он ведёт себя иначе, чем рассмотренные здесь примитивы: это объект, он неизменяемый (immutable), а у сравнения строк есть свои подводные камни. Об этом - на следующей странице.