Зачем запускать ArrayList с начальной емкостью?

Обычный конструктор ArrayList:

ArrayList<?> list = new ArrayList<>();

Но есть также перегруженный конструктор с параметром для его начальной емкости:

ArrayList<?> list = new ArrayList<>(20);

Почему полезно создать ArrayListисходную емкость, когда мы можем добавлять ее, как пожелаем?

Если вы заранее знаете, каким будет размер ArrayList, более эффективно указать начальную емкость. Если вы этого не сделаете, внутренний массив придется многократно перераспределять по мере роста списка.

Чем больше итоговый список, тем больше времени вы экономите, избегая перераспределений.

Тем не менее, даже без предварительного выделения, вставка nэлементов в конце ArrayListгарантированно займет общее O(n)время. Другими словами, добавление элемента является амортизированной операцией с постоянным временем. Это достигается за счет того, что каждое перераспределение увеличивает размер массива экспоненциально, как правило, на коэффициент 1.5. При таком подходе общее количество операций может быть показано какO(n) .

Потому ArrayListчто это динамически изменяемая структура данных массива , что означает, что он реализован как массив с начальным (по умолчанию) фиксированным размером. Когда это заполнится, массив будет расширен до двойного размера. Эта операция является дорогостоящей, поэтому вы хотите как можно меньше.

Итак, если вы знаете, что ваша верхняя граница равна 20 элементам, то создание массива с начальной длиной 20 лучше, чем использование значения по умолчанию, скажем, 15, а затем изменить его размер 15*2 = 30и использовать только 20, тратя впустую циклы для расширения.

PS - Как говорит AmitG, коэффициент расширения зависит от конкретной реализации (в данном случае (oldCapacity * 3)/2 + 1)

Размер по умолчанию Arraylist составляет 10 .

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
    this(10);
    } 

Таким образом, если вы собираетесь добавить 100 или более записей, вы можете увидеть издержки перераспределения памяти.

ArrayList<?> list = new ArrayList<>();    
// same as  new ArrayList<>(10);      

Поэтому, если у вас есть представление о количестве элементов, которые будут храниться в Arraylist, лучше создать Arraylist с таким размером, а не начинать с 10, а затем увеличивать его.

Я фактически написал сообщение в блоге на тему 2 месяца назад. Статья предназначена для C #, List<T>но Java ArrayListимеет очень похожую реализацию. Так ArrayListкак реализован с использованием динамического массива, он увеличивается в размере по требованию. Поэтому причина для конструктора емкости - в целях оптимизации.

Когда происходит одна из этих операций изменения размеров, ArrayList копирует содержимое массива в новый массив, который в два раза больше емкости старого. Эта операция выполняется за O (n) времени.

пример

Вот пример того, как ArrayListразмер увеличится:

10
16
25
38
58
... 17 resizes ...
198578
297868
446803
670205
1005308

Таким образом, список начинается с емкости 10, при добавлении 11-го элемента он увеличивается 50% + 1до 16. На 17-м пункте ArrayListснова увеличен до 25и так далее. Теперь рассмотрим пример, в котором мы создаем список, в котором желаемая емкость уже известна как 1000000. Создание конструктора ArrayListбез размера вызовет ArrayList.add 1000000время, которое обычно занимает O (1) или O (n) при изменении размера.

1000000 + 16 + 25 + ... + 670205 + 1005308 = 4015851 операций

Сравните это, используя конструктор, а затем вызов, ArrayList.addкоторый гарантированно будет выполняться в O (1) .

1000000 + 1000000 = 2000000 операций

Java против C #

Java как и выше, начиная с 10каждого размера и увеличивая его 50% + 1. C # начинается 4и увеличивается гораздо агрессивнее, удваивается при каждом изменении размера. Добавленный 1000000пример сверху для C # использует 3097084операции.

Ссылки

• Мой блог в списке C # <T>
• Исходный код Java ArrayList

Установка начального размера ArrayList, например ArrayList<>(100), уменьшает количество раз, когда должно происходить перераспределение внутренней памяти.

Пример:

ArrayList example = new ArrayList<Integer>(3);
example.add(1); // size() == 1
example.add(2); // size() == 2, 
example.add(2); // size() == 3, example has been 'filled'
example.add(3); // size() == 4, example has been 'expanded' so that the fourth element can be added. 

Как вы видите в приведенном выше примере - an ArrayListможет быть расширен при необходимости. Это не показывает, что размер Arraylist обычно удваивается (хотя обратите внимание, что новый размер зависит от вашей реализации). Следующее цитата из Oracle :

«Каждый экземпляр ArrayList имеет емкость. Емкость - это размер массива, используемого для хранения элементов в списке. Он всегда по меньшей мере равен размеру списка. Когда элементы добавляются в ArrayList, его емкость автоматически увеличивается. Детали политики роста не указаны за исключением того факта, что добавление элемента имеет постоянные амортизированные временные затраты ».

Очевидно, что если вы не знаете, какой диапазон вы будете удерживать, установка размера, вероятно, не будет хорошей идеей - однако, если у вас есть определенный диапазон, установка начальной емкости увеличит эффективность памяти ,

ArrayList может содержать много значений, и при выполнении больших начальных вставок вы можете указать ArrayList выделять больший объем памяти для начала, чтобы не тратить циклы ЦП, когда он пытается выделить больше места для следующего элемента. Таким образом, выделить немного места в начале более эффективно.

Это позволяет избежать возможных усилий по перераспределению для каждого отдельного объекта.

int newCapacity = (oldCapacity * 3)/2 + 1;

внутренне new Object[]создан.
JVM требует усилий для создания, new Object[]когда вы добавляете элемент в массив. Если у вас нет кода выше (любой алго вам кажется) для перераспределения затем каждый раз , когда вы вызываете , arraylist.add()то new Object[]должен быть создан , который не имеет смысла , и мы теряем время для увеличения размера на 1 для каждого объекта , которые будут добавлены. Так что лучше увеличить размер Object[]с помощью следующей формулы.
(JSL использовала формулу прогнозирования, приведенную ниже для динамически растущего массива, вместо того, чтобы каждый раз увеличиваться на 1. Потому что для роста требуется усилие JVM)

int newCapacity = (oldCapacity * 3)/2 + 1;

Я думаю, что каждый ArrayList создан со значением емкости инициализации "10". Так или иначе, если вы создадите ArrayList без установки емкости в конструкторе, он будет создан со значением по умолчанию.

Я бы сказал, что это оптимизация. ArrayList без начальной емкости будет иметь ~ 10 пустых строк и будет расширяться при добавлении.

Чтобы получить список с точным количеством элементов, вам нужно вызвать trimToSize ()

Согласно моему опыту ArrayList, предоставление начальной емкости - хороший способ избежать затрат на перераспределение. Но это несет оговорку. Все предложения, упомянутые выше, говорят о том, что исходную емкость следует указывать только тогда, когда известна приблизительная оценка количества элементов. Но когда мы пытаемся дать начальную емкость без какой-либо идеи, объем зарезервированной и неиспользованной памяти будет пустой тратой, поскольку она может никогда не потребоваться после заполнения списка требуемым количеством элементов. Я хочу сказать, что в начале мы можем прагматично распределять емкость, а затем находить разумный способ узнать требуемую минимальную емкость во время выполнения. ArrayList предоставляет метод с именем ensureCapacity(int minCapacity). Но тогда нужно найти умный способ ...

Я протестировал ArrayList с и без initialCapacity и получил удивительный результат
Когда я установил для LOOP_NUMBER значение 100 000 или меньше, результатом является то, что установка initialCapacity эффективна.

list1Sttop-list1Start = 14
list2Sttop-list2Start = 10

Но когда я установил LOOP_NUMBER в 1,000,000, результат изменится на:

list1Stop-list1Start = 40
list2Stop-list2Start = 66

Наконец, я не мог понять, как это работает ?!
Образец кода:

 public static final int LOOP_NUMBER = 100000;

public static void main(String[] args) {

    long list1Start = System.currentTimeMillis();
    List<Integer> list1 = new ArrayList();
    for (int i = 0; i < LOOP_NUMBER; i++) {
        list1.add(i);
    }
    long list1Stop = System.currentTimeMillis();
    System.out.println("list1Stop-list1Start = " + String.valueOf(list1Stop - list1Start));

    long list2Start = System.currentTimeMillis();
    List<Integer> list2 = new ArrayList(LOOP_NUMBER);
    for (int i = 0; i < LOOP_NUMBER; i++) {
        list2.add(i);
    }
    long list2Stop = System.currentTimeMillis();
    System.out.println("list2Stop-list2Start = " + String.valueOf(list2Stop - list2Start));
}

Я проверил на Windows8.1 и JDK1.7.0_80