Perché avviare una matrice con una capacità iniziale?

Il solito costruttore di ArrayListè:

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

Ma c'è anche un costruttore sovraccarico con un parametro per la sua capacità iniziale:

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

Perché è utile creare un ArrayListcon una capacità iniziale quando possiamo accedervi a nostro piacimento?

Se si conosce in anticipo quale sarà la dimensione ArrayListdell'elemento, è più efficiente specificare la capacità iniziale. In caso contrario, l'array interno dovrà essere riallocato ripetutamente man mano che l'elenco cresce.

Più grande è l'elenco finale, più tempo risparmi evitando le riallocazioni.

Detto questo, anche senza pre-allocazione, l'inserimento di nelementi sul retro di un ArrayListè garantito per prendere il O(n)tempo totale . In altre parole, aggiungere un elemento è un'operazione a tempo costante ammortizzata. Ciò si ottiene facendo in modo che ogni riallocazione aumenti esponenzialmente le dimensioni dell'array, in genere di un fattore di 1.5. Con questo approccio, si può dimostrare cheO(n) il numero totale di operazioni è .

Perché ArrayListè una struttura di dati di array ridimensionamento dinamico , il che significa che è implementato come un array con una dimensione fissa iniziale (predefinita). Quando questo viene riempito, l'array verrà esteso a uno di dimensioni doppie. Questa operazione è costosa, quindi vuoi il minor numero possibile.

Quindi, se sai che il limite superiore è di 20 elementi, creare l'array con una lunghezza iniziale di 20 è meglio che usare un valore predefinito di, diciamo, 15 e quindi ridimensionarlo 15*2 = 30e usare solo 20 sprecando i cicli per l'espansione.

PS: come afferma AmitG, il fattore di espansione è specifico dell'implementazione (in questo caso (oldCapacity * 3)/2 + 1)

La dimensione predefinita di Arraylist è 10 .

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

Quindi, se hai intenzione di aggiungere 100 o più record, puoi vedere l'overhead della riallocazione della memoria.

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

Quindi, se hai idea del numero di elementi che verranno memorizzati in Arraylist, è meglio creare Arraylist con quella dimensione invece di iniziare con 10 e continuare ad aumentarlo.

In realtà ho scritto un post sul blog sull'argomento 2 mesi fa. L'articolo è per C # List<T>ma Java ArrayListha un'implementazione molto simile. Poiché ArrayListè implementato utilizzando un array dinamico, aumenta di dimensioni su richiesta. Quindi il motivo del costruttore di capacità è a fini di ottimizzazione.

Quando si verifica una di queste operazioni di ridimensionamento, ArrayList copia il contenuto dell'array in un nuovo array che è il doppio della capacità di quello precedente. Questa operazione viene eseguita in O (n) tempo.

Esempio

Ecco un esempio di come ArrayListaumenterebbe la dimensione:

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

Quindi l'elenco inizia con una capacità di 10, quando viene aggiunto l'undicesimo elemento, aumenta di 50% + 1a 16. Al 17 ° oggetto ArrayListviene nuovamente aumentato a 25e così via. Consideriamo ora l'esempio in cui stiamo creando un elenco in cui la capacità desiderata è già nota come 1000000. La creazione del ArrayListcostruttore senza dimensione chiamerà i ArrayList.add 1000000tempi che richiedono normalmente O (1) o O (n) al ridimensionamento.

1000000 + 16 + 25 + ... + 670205 + 1005308 = 4015851 operazioni

Confronta questo usando il costruttore e poi chiamando ArrayList.addche è garantito per essere eseguito in O (1) .

1000000 + 1000000 = 2000000 operazioni

Java vs C #

Java è come sopra, a partire da 10e aumentando ogni ridimensionamento a 50% + 1. C # inizia da 4e aumenta in modo molto più aggressivo, raddoppiando ad ogni ridimensionamento. L' 1000000esempio sopra riportato per C # usa le 3097084operazioni.

Riferimenti

• Il mio post sul blog nell'elenco di C # <T>
• Codice sorgente ArrayList di Java

L'impostazione della dimensione iniziale di una ArrayList, ad esempio su ArrayList<>(100), riduce il numero di volte in cui deve avvenire la riassegnazione della memoria interna.

Esempio:

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. 

Come vedi nell'esempio sopra, è ArrayListpossibile espandere se necessario. Ciò che ciò non ti mostra è che la dimensione dell'Arraylist di solito raddoppia (anche se nota che la nuova dimensione dipende dalla tua implementazione). Quanto segue è citato da Oracle :

"Ogni istanza di ArrayList ha una capacità. La capacità è la dimensione dell'array utilizzato per memorizzare gli elementi nell'elenco. È sempre almeno grande quanto la dimensione dell'elenco. Man mano che gli elementi vengono aggiunti ad un ArrayList, la sua capacità aumenta automaticamente. I dettagli della politica di crescita non sono specificati oltre al fatto che l'aggiunta di un elemento ha un costo temporale ammortizzato costante. "

Ovviamente, se non hai idea di quale tipo di intervallo manterrai, impostare le dimensioni probabilmente non sarà una buona idea - tuttavia, se hai in mente un intervallo specifico, l'impostazione di una capacità iniziale aumenterà l'efficienza della memoria .

ArrayList può contenere molti valori e quando si eseguono inserimenti iniziali di grandi dimensioni, si può dire ad ArrayList di allocare uno spazio di archiviazione più grande per iniziare per non sprecare i cicli della CPU quando si tenta di allocare più spazio per l'elemento successivo. Pertanto, allocare un po 'di spazio all'inizio è più efficace.

Questo per evitare possibili sforzi di riallocazione per ogni singolo oggetto.

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

new Object[]viene creato internamente .
JVM ha bisogno di sforzi per creare new Object[]quando aggiungi un elemento nell'arraylist. Se non si dispone di un codice sopra (nessun algo che si pensa) per la riallocazione, ogni volta che si invoca arraylist.add()si new Object[]deve creare il che è inutile e stiamo perdendo tempo per aumentare le dimensioni di 1 per ogni singolo oggetto da aggiungere. Quindi è meglio aumentare le dimensioni di Object[]con la seguente formula.
(JSL ha usato la formula di forcasting indicata di seguito per l'arraylist a crescita dinamica invece di crescere di 1 ogni volta. Perché per crescere ci vuole sforzo da JVM)

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

Penso che ogni ArrayList sia creato con un valore di capacità init di "10". Quindi, se si crea un ArrayList senza impostare la capacità all'interno del costruttore, verrà creato con un valore predefinito.

Direi che è un'ottimizzazione. ArrayList senza capacità iniziale avrà ~ 10 righe vuote e si espanderà quando si esegue un'aggiunta.

Per avere un elenco con esattamente il numero di elementi è necessario chiamare trimToSize ()

Secondo la mia esperienza con ArrayList, dare una capacità iniziale è un buon modo per evitare i costi di riallocazione. Ma porta un avvertimento. Tutti i suggerimenti sopra menzionati affermano che si dovrebbe fornire la capacità iniziale solo quando si conosce una stima approssimativa del numero di elementi. Ma quando proviamo a dare una capacità iniziale senza alcuna idea, la quantità di memoria riservata e inutilizzata sarà uno spreco in quanto potrebbe non essere mai richiesto una volta che l'elenco viene riempito per il numero richiesto di elementi. Quello che sto dicendo è che possiamo essere pragmatici all'inizio durante l'allocazione della capacità e quindi trovare un modo intelligente di conoscere la capacità minima richiesta in fase di esecuzione. ArrayList fornisce un metodo chiamato ensureCapacity(int minCapacity). Ma poi, si è trovato un modo intelligente ...

Ho testato ArrayList con e senza initialCapacity e ho ottenuto risultati sorprendenti
Quando ho impostato LOOP_NUMBER su 100.000 o meno, il risultato è che l'impostazione di InitCapacity è efficiente.

list1Sttop-list1Start = 14
list2Sttop-list2Start = 10

Ma quando imposto LOOP_NUMBER su 1.000.000 il risultato cambia in:

list1Stop-list1Start = 40
list2Stop-list2Start = 66

Infine, non sono riuscito a capire come funziona ?!
Codice di esempio:

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

Ho testato su Windows 8.1 e jdk1.7.0_80