Изменится ли потребляемая память при вызове clear к ArrayList

# Изменится ли потребляемая память при вызове clear к ArrayList

Краткий ответ

Нет, потребляемая память практически не изменится сразу после вызова clear(), но может быть освобождена при следующем сборе мусора. Объекты останутся в памяти до GC.

Подробное объяснение

Что происходит при вызове clear()

public void clear() {
    modCount++;
    for (int i = 0; i < size; i++)
        elementData[i] = null;  // Обнуляем ссылки
    size = 0;  // Устанавливаем размер в 0
}

Метод clear() делает две вещи:

1. Обнуляет все ссылки на элементы массива (elementData[i] = null)
2. Устанавливает size = 0

Память остаётся выделена!

Принципиально важный момент: внутренний массив elementData сохраняет свой размер.

ArrayList<Integer> list = new ArrayList<>();
list.ensureCapacity(10000);  // Выделяем память для 10000 элементов
list.add(1);
list.add(2);
list.add(3);

System.out.println("Размер (size): " + list.size());  // 3
// Но внутренний массив всё ещё размером 10000!

list.clear();  // Обнуляет ссылки
System.out.println("Размер (size): " + list.size());  // 0
// Массив всё ещё размером 10000!

Когда освобождается память

Сценарий 1: Сборка мусора После clear() все элементы были обнулены (null), поэтому на них нет ссылок. Сборщик мусора может их удалить, но сам массив elementData остаётся.

list.clear();
System.gc();  // Явный вызов GC (не гарантирует выполнение)
// Элементы удалены, но массив всё ещё в памяти

Сценарий 2: Использование trimToSize() Если нужно освободить неиспользуемое место в массиве:

ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
    list.add("item " + i);
}
System.out.println("Capacity: " + list.size());  // 10000

list.clear();
list.trimToSize();  // Уменьшает массив до размера 0
// Теперь память действительно освобождается

Практическое измерение

import java.util.ArrayList;

public class MemoryTest {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add("String " + i);
        }
        
        long memoryBefore = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("Память до clear: " + (memoryBefore / 1024 / 1024) + " MB");
        
        list.clear();  // Обнуляет ссылки
        long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("Память после clear: " + (memoryAfter / 1024 / 1024) + " MB");
        // Память примерно такая же!
        
        list.trimToSize();  // Освобождает память
        System.gc();  // Запускаем GC
        long memoryTrimmed = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("Память после trimToSize + GC: " + (memoryTrimmed / 1024 / 1024) + " MB");
        // Теперь существенно меньше
    }
}

Сравнение с другими методами

Ответ на интервью

При вызове clear() на ArrayList размер списка становится 0, но внутренний массив сохраняет свой размер. Ссылки на элементы обнуляются, позволяя сборщику мусора удалить объекты, но сам массив остаётся выделённым в памяти. Для полного освобождения памяти нужно вызвать trimToSize(), который создаст новый, меньший массив.

Почему это важно

1. Производительность: Если часто добавлять/очищать, clear() эффективнее, чем пересоздавать список
2. Утечки памяти: Если очистить список, но он всё ещё в памяти с большой ёмкостью, это может быть проблемой
3. Проектирование: Нужно понимать разницу между логическим размером (size) и физической ёмкостью (capacity)