Массив является примитивом или объектом

Массивы в Java: сложный статус между примитивом и объектом

Прямой ответ

Массив — это ОБЪЕКТ, хотя часто путают с примитивом. Официально в Java Language Specification (JLS) массив классифицируется как reference type (ссылочный тип), а не примитивный тип.

Почему массив — это объект

1. Массив наследует java.lang.Object

int[] numbers = {1, 2, 3};

// Все методы Object доступны:
System.out.println(numbers.getClass());  // class [I
System.out.println(numbers.toString());  // [I@2a139a55 (адрес в памяти)
System.out.println(numbers.hashCode());  // 710585859

// Наследует equals() (сравнивает по ссылке, не по содержимому)
int[] arr1 = {1, 2};
int[] arr2 = {1, 2};
System.out.println(arr1.equals(arr2));  // false! Разные объекты

2. Массив имеет идентичность (identity)

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;  // Обе переменные указывают на ОДИН объект

System.out.println(arr1 == arr2);        // true (одна ссылка)
System.out.println(System.identityHashCode(arr1));  // Адрес в памяти
System.out.println(System.identityHashCode(arr2));  // ТОТ ЖЕ адрес

3. Массив хранится в heap

public class ArrayMemoryDemo {
    public static void main(String[] args) {
        // Stack: переменная arr указывает на объект в heap
        int[] arr = new int[1000000];  // 4MB в heap
        
        // Stack память: ~8 байт (только ссылка)
        // Heap память: 4MB (сами данные)
        
        // Если массив примитив, он должен быть в stack
        // Но НИКОГДА не можешь разместить большой массив в stack:
        // int stack_arr[1000000];  // ОШИБКА: too large
    }
}

4. Массив — ссылочный тип (reference type)

// Примитивные типы:
int x = 5;      // Значение прямо в стеке
int y = x;      // Копирует значение

// Массив — ссылочный тип:
int[] arr1 = {1, 2, 3};  // Ссылка на объект в heap
int[] arr2 = arr1;       // Копирует ССЫЛКУ, не данные

// Изменение через arr1 видно и в arr2:
arr1[0] = 999;
System.out.println(arr2[0]);  // 999!

Поддержка null

// Примитив не может быть null:
int x = null;  // ОШИБКА компиляции

// Массив может быть null (это ссылочный тип):
int[] arr = null;  // OK
if (arr != null) {
    System.out.println(arr[0];
}

Таблица: примитив vs массив

Компилятор и массивы

// В compile-time массивы получают синтетическое имя класса:
int[] arr = {1, 2};         // Класс: [I (array of int)
String[] strings = {...};   // Класс: [Ljava/lang/String; 
double[][] matrix = {...}; // Класс: [[D (array of array of double)

// Можешь проверить тип:
System.out.println(arr.getClass().getName());      // "[I"
System.out.println(arr instanceof int[]);           // true
System.out.println(arr instanceof Object);          // true
System.out.println(arr instanceof Cloneable);       // true!
System.out.println(arr instanceof Serializable);    // true!

Массив имплементирует интерфейсы Object

int[] arr = {1, 2, 3};

// Все массивы имплементируют:
// 1. Cloneable
int[] copy = arr.clone();  // Поверхностная копия

// 2. Serializable
byte[] bytes = new java.io.ByteArrayOutputStream();
var oos = new java.io.ObjectOutputStream(...);
oos.writeObject(arr);  // Можешь сериализовать

// 3. Comparable (для некоторых типов в Java 19+)
// Arrays.compare(arr1, arr2);

Почему люди думают, что массив — примитив

Причина 1: Синтаксис похож на примитивы

int x = 5;           // Выглядит просто
int[] arr = {1, 2};  // Синтаксис похож

// Но за кулисами:
// int x = 5;        → значение в stack
// int[] arr = ...;  → ссылка в stack, массив в heap

Причина 2: Примитивные элементы

int[] arr = {1, 2, 3};  // Элементы — примитивы (int)

// Но сам массив — объект!
// Путница: элементы примитивные, контейнер — объект

Причина 3: Нет явного new

// Можешь создать без явного new:
int[] arr = {1, 2, 3};

// Но компилятор преобразует в:
int[] arr = new int[]{1, 2, 3};

Практические последствия

Consequence 1: equals() не сравнивает содержимое

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};

// НЕПРАВИЛЬНО для массивов:
if (arr1.equals(arr2)) {  // false! Сравнивает ссылки
    System.out.println("Equal");
}

// ПРАВИЛЬНО:
if (Arrays.equals(arr1, arr2)) {  // true!
    System.out.println("Equal");
}

Consequence 2: Передача в функцию

public void modifyArray(int[] arr) {
    arr[0] = 999;  // Изменит исходный массив!
}

int[] original = {1, 2, 3};
modifyArray(original);
System.out.println(original[0]);  // 999

// Передаёшь ССЫЛКУ, не копию!

Consequence 3: Heap pressure

// Миллион массивов создаёт давление на heap:
List<int[]> lists = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
    lists.add(new int[100]);  // 1M объектов в heap!
}
// GC может быть проблемой

Иллюстрация в памяти

STACK:                    HEAP:
┌──────────────┐         ┌────────────────────┐
│ arr (ссылка) │────────►│ int[3] {1, 2, 3}  │
│              │         │                    │
│ x = 5        │         │ [0] = 1            │
│              │         │ [1] = 2            │
│              │         │ [2] = 3            │
│              │         │ length = 3         │
│              │         └────────────────────┘

Вывод

Массив — это ОБЪЕКТ, не примитив, потому что:

1. Наследует java.lang.Object — получает toString(), equals(), hashCode(), hashCode()
2. Имплементирует Cloneable и Serializable — можешь клонировать и сериализовать
3. Хранится в heap — не в stack
4. Ссылочный тип — передаётся по ссылке
5. Может быть null — примитив не может
6. instanceof работает — для ссылочных типов

Различие:

• int (примитив) — значение
• int[] (массив объектов) — ссылка на объект в heap
• Integer (обёртка) — тоже объект, но оборачивает примитив

Это фундаментальное понимание критично для:

• Управления памятью и GC
• Передачи параметров в функции
• Работы с collections
• Оптимизации производительности