Какой размер начального массива у ArrayList?

Размер начального массива у ArrayList в Java

Этот вопрос имеет подвох и требует понимания внутренней реализации класса ArrayList в Java, особенно его эволюции в разных версиях JDK.

Краткий ответ: зависит от версии JDK

• В большинстве современных версий JDK (1.8 и выше) начальный размер массива (elementData) равен 0. ArrayList создается пустым.
• В более старых версиях JDK (например, 1.6 и некоторых реализациях 1.7) начальный размер массива был 10.

Ключевой момент заключается в том, что ArrayList использует стратегию ленивой инициализации (lazy initialization) в современных JDK для оптимизации памяти. Массив создается не при создании объекта ArrayList, а только при первой операции добавления элемента (add()).

Детальное объяснение и примеры кода

Давайте посмотрим на внутреннюю реализацию.

1. Конструкторы ArrayList

// Конструктор без параметров - самый распространенный
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// Конструктор с начальной емкостью
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}

2. Поля-массивы для ленивой инициализации

// В JDK 1.8+ и выше
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final Object[] EMPTY_ELEMENTDATA = {};
transient Object[] elementData;

Как видим, DEFAULTCAPACITY_EMPTY_ELEMENTDATA — это пустой массив. При создании ArrayList через конструктор без параметров, поле elementData просто ссылается на этот пустой статический массив. Реальный массив создается позже.

3. Создание массива при первой операции добавления

Логика создания массива заключена в методах add() и ensureCapacityInternal().

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

// DEFAULT_CAPACITY по-прежнему равен 10, но это лишь желаемая начальная емкость при первом добавлении
private static final int DEFAULT_CAPACITY = 10;

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

Процесс при первом добавлении (add()) в пустой ArrayList:

• Проверяется, если elementData равен DEFAULTCAPACITY_EMPTY_ELEMENTDATA.
• Если это так, вычисляется минимальная емкость как максимум между DEFAULT_CAPACITY (10) и требуемой емкостью.
• Затем вызывается ensureExplicitCapacity() и, если нужно, создается новый массив размером 10 через grow().

Пример:

ArrayList<String> list = new ArrayList<>();
// На этом этапе list.elementData == DEFAULTCAPY_EMPTY_ELEMENTDATA (массив размером 0)
System.out.println(list.size()); // Вывод: 0

list.add("Hello");
// Теперь внутри создан массив Object[10], и в него помещен элемент "Hello"
System.out.println(list.size()); // Вывод: 1

Почему изменилось поведение? Причины ленивой инициализации

• Экономия памяти: Если создается множество пустых ArrayList (например, в коллекциях объектов), которые могут никогда не заполняться, выделение массива из 10 элементов для каждого из них приводит к бесполезному расходу памяти.
• Умная оптимизация: Плата за создание массива переносится на момент, когда он действительно нужен — при первой операции добавления.
• Стандартная начальная емкость (10) остается: При первом добавлении все равно создается массив размером 10 (если не требуется больший), сохраняя эффективность при небольших объемах данных.

Итог и важные выводы для собеседования

• Текущая реализация (JDK 8+): начальный размер массива 0. Массив создается размером 10 при первом вызове add().
• Старые версии: могли сразу создавать массив размером 10.
• Вы можете управлять начальной емкостью: используя конструктор ArrayList(int initialCapacity), чтобы избежать возможных resize операций, если заранее известен приблизительный размер списка.
• Resize операция: при добавлении элементов сверх текущей емкости, массив увеличивается примерно на 50% (формула: newCapacity = oldCapacity + (oldCapacity >> 1)), что требует создания нового массива и копирования данных.

Таким образом, правильный и полный ответ должен отражать понимание ленивой инициализации и эволюции класса, а не просто назвать число 10 или 0. Это показывает глубокое знание внутренних механизмов стандартной библиотеки Java.