Por que iniciar um ArrayList com capacidade inicial?

O construtor usual de ArrayListé:

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

Mas há também um construtor sobrecarregado com um parâmetro para sua capacidade inicial:

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

Por que é útil criar um ArrayListcom uma capacidade inicial quando podemos anexá-lo como quisermos?

Se você sabe com antecedência qual será o tamanho da ArrayListsolução, é mais eficiente especificar a capacidade inicial. Se você não fizer isso, a matriz interna precisará ser realocada repetidamente à medida que a lista aumentar.

Quanto maior a lista final, mais tempo você economiza, evitando as realocações.

Dito isto, mesmo sem pré-alocação, é garantido que a inserção de nelementos na parte de trás de um tempo ArrayListtotal O(n). Em outras palavras, anexar um elemento é uma operação de tempo constante amortizada. Isso é obtido fazendo com que cada realocação aumente exponencialmente o tamanho da matriz, geralmente por um fator de 1.5. Com essa abordagem, o número total de operações pode ser demonstradoO(n) .

Porque ArrayListé uma estrutura de dados de matriz de redimensionamento dinâmico , o que significa que ela é implementada como uma matriz com um tamanho fixo inicial (padrão). Quando isso for preenchido, a matriz será estendida para uma de tamanho duplo. Como esta operação é cara, você deseja o mínimo possível.

Portanto, se você sabe que seu limite superior é de 20 itens, é melhor criar o array com comprimento inicial de 20 do que usar um padrão de, digamos, 15 e redimensioná-lo 15*2 = 30e usar apenas 20 enquanto desperdiça os ciclos da expansão.

PS - Como o AmitG diz, o fator de expansão é específico da implementação (neste caso (oldCapacity * 3)/2 + 1)

O tamanho padrão da matriz é 10 .

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

Portanto, se você quiser adicionar 100 ou mais registros, poderá ver a sobrecarga da realocação de memória.

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

Portanto, se você tem alguma idéia sobre o número de elementos que serão armazenados no Arraylist, é melhor criar o Arraylist com esse tamanho, em vez de começar com 10 e depois aumentá-lo.

Na verdade, eu escrevi um post sobre o tópico há 2 meses. O artigo é para C #, List<T>mas o Java ArrayListtem uma implementação muito semelhante. Como ArrayListé implementado usando uma matriz dinâmica, aumenta em tamanho sob demanda. Portanto, o motivo do construtor de capacidade é para fins de otimização.

Quando uma dessas operações de redimensionamento ocorre, o ArrayList copia o conteúdo da matriz em uma nova matriz com o dobro da capacidade da antiga. Esta operação é executada em O (n) tempo.

Exemplo

Aqui está um exemplo de como o ArrayListtamanho aumentaria:

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

Portanto, a lista começa com uma capacidade de 10, quando o 11º item é adicionado, é aumentado em 50% + 1para 16. No 17º item, o valor ArrayListé aumentado novamente para 25e assim por diante. Agora considere o exemplo em que estamos criando uma lista em que a capacidade desejada já é conhecida 1000000. Criar o ArrayListconstrutor sem o tamanho chamará ArrayList.add 1000000tempos que levam O (1) normalmente ou O (n) no redimensionamento.

1000000 + 16 + 25 + ... + 670205 + 1005308 = 4015851 operações

Compare isso usando o construtor e, em seguida, chamando, ArrayList.addque é garantido para executar em O (1) .

1000000 + 1000000 = 2000000 operações

Java vs C #

Java é como acima, iniciando 10e aumentando cada redimensionamento em 50% + 1. O C # inicia 4e aumenta muito mais agressivamente, dobrando a cada redimensionamento. O 1000000exemplo adiciona acima para C # usa 3097084operações.

Referências

• Minha postagem no blog na lista de C # <T>
• Código-fonte ArrayList do Java

Definir o tamanho inicial de um ArrayList, por exemplo, para ArrayList<>(100), reduz o número de vezes que a realocação da memória interna deve ocorrer.

Exemplo:

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. 

Como você pode ver no exemplo acima, um ArrayListpode ser expandido, se necessário. O que isso não mostra é que o tamanho da Lista de matriz geralmente dobra (embora observe que o novo tamanho depende da sua implementação). O seguinte é citado da Oracle :

"Cada instância ArrayList tem capacidade. A capacidade é o tamanho da matriz usada para armazenar os elementos na lista. É sempre pelo menos tão grande quanto o tamanho da lista. À medida que os elementos são adicionados a um ArrayList, sua capacidade aumenta automaticamente. Os detalhes da política de crescimento não são especificados além do fato de que a adição de um elemento tem custo de tempo amortizado constante ".

Obviamente, se você não tem idéia do tipo de intervalo que estará mantendo, definir o tamanho provavelmente não será uma boa ideia - no entanto, se você tiver um intervalo específico em mente, definir uma capacidade inicial aumentará a eficiência da memória .

O ArrayList pode conter muitos valores e, ao fazer inserções iniciais grandes, você pode solicitar ao ArrayList que aloque um armazenamento maior para começar, a fim de não desperdiçar os ciclos da CPU ao tentar alocar mais espaço para o próximo item. Assim, alocar algum espaço no início é mais eficiente.

Isso é para evitar possíveis esforços de realocação para cada objeto.

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

internamente new Object[]é criado.
A JVM precisa de esforço para criar new Object[]quando você adiciona elemento na lista de matrizes. Se você não tem o código acima (qualquer algo que você pensa) para realocação, em seguida, cada vez que quando você chamar arraylist.add(), em seguida, new Object[]tem de ser criado que é inútil e estamos perdendo tempo para aumentar o tamanho de 1 para cada objetos a ser adicionado. Portanto, é melhor aumentar o tamanho Object[]com a seguinte fórmula.
(A JSL usou a fórmula de transmissão fornecida abaixo para aumentar dinamicamente o arraylist em vez de aumentar 1 sempre. Porque para crescer, é necessário um esforço da JVM)

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

Eu acho que cada ArrayList é criado com um valor de capacidade init de "10". De qualquer maneira, se você criar um ArrayList sem definir capacidade no construtor, ele será criado com um valor padrão.

Eu diria que é uma otimização. ArrayList sem capacidade inicial terá ~ 10 linhas vazias e se expandirá quando você estiver adicionando.

Para ter uma lista com exatamente o número de itens que você precisa chamar trimToSize ()

De acordo com minha experiência com ArrayList, fornecer uma capacidade inicial é uma boa maneira de evitar custos de realocação. Mas tem uma ressalva. Todas as sugestões mencionadas acima dizem que só se deve fornecer capacidade inicial quando se conhece uma estimativa aproximada do número de elementos. Mas quando tentamos fornecer uma capacidade inicial sem nenhuma idéia, a quantidade de memória reservada e não utilizada será um desperdício, pois talvez nunca seja necessária uma vez que a lista seja preenchida com o número necessário de elementos. O que estou dizendo é que podemos ser pragmáticos no início enquanto alocamos capacidade e, em seguida, encontrar uma maneira inteligente de saber a capacidade mínima necessária em tempo de execução. ArrayList fornece um método chamado ensureCapacity(int minCapacity). Mas então, encontramos uma maneira inteligente ...

Testei ArrayList com e sem initialCapacity e obtive um resultado surpreendente.
Quando defino LOOP_NUMBER para 100.000 ou menos, o resultado é que a configuração de initialCapacity é eficiente.

list1Sttop-list1Start = 14
list2Sttop-list2Start = 10

Mas quando defino LOOP_NUMBER como 1.000.000, o resultado muda para:

list1Stop-list1Start = 40
list2Stop-list2Start = 66

Finalmente, eu não conseguia descobrir como isso funciona ?!
Código de amostra:

 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));
}

Eu testei no windows8.1 e jdk1.7.0_80