Standard-Größe der ArrayList

Blick durch einige Stück code, das ich bemerkte eine seltsame Initialisierung der ArrayList:

... = new ArrayList<..>(0);

Habe ich geöffnet JavaSE 7 Quellen und sah, daß innere elementData arrray wird initialisiert durch leere array-Konstante - {}. Wenn wir an die Fähigkeit, die ArrayList Konstruktor wir machen fast das gleiche - new Object[0]. Also meine Frage ist: gibt es einen Unterschied zwischen neuen ArrayList(0) und new ArrayList() ? Sollte nicht ArrayList legen Sie die Standard-Kapazität Größe smth wie 10 ?

Danke an alle für die Antworten.

Mögliche Duplikate von Warum ist die Standard-Kapazität von ArrayList 10?
Es ist anscheinend geändert worden. In diesen Tagen werden die Standard-Kapazität ist tatsächlich 0. Gut, das ist ein bisschen Semantik. Wenn die Initialisierung der Standard-Kapazität ist 0, die erhöht sich auf 10, wenn nichts eingelegt ist.
könnten Sie bitte zeigen Sie mir, wo finde ich die Erklärung, warum Standard-Größe 0 ist in diesem thread ?
Meine Frage selbst beantwortet: die Anfängliche Größe ist 0, springt auf 10 bei der ersten Benutzung. Anfänglichen Kapazität ist 10, aber es ist träge geladen.
don ' T mix Größe und Kapazität! Kapazität beginnt bei 10. Solange die aktuelle Größe 0-10 die Kapazität gewonnen ' Y geändert werden, sobald Sie genug Elemente, um die Größe größer als 10 ist, wird die Leistungsfähigkeit "erhöhte" durch das erstellen eines neuen array und kopieren Sie alles über
tatsächlich mache ich mir sorgen über die Größe des internen Arrays, insbesondere für den Fall, wenn wir, um eine neue ArrayList.
Zur info; das ist dieser post könnte dir helfen : stackoverflow.com/questions/34250207/...

InformationsquelleAutor Dedyshka | 2016-02-08

4

Einer ArrayList hat ein internes array zum speichern der Liste Elemente.

Gibt es einen Unterschied zwischen den beiden Konstruktor-Aufrufe in Java 7 und 8:

Wenn Sie new ArrayList<>(0) die ArrayList erstellt ein neues Objekt-array der Größe 0.

Wenn Sie new ArrayList<>() die ArrayList verwendet ein statisches, leeres Object-array der Größe 0 und wechselt in ein eigenes array sobald Sie Objekte zu der Liste hinzuzufügen.

EDIT:

In der Javadoc der Standard - ArrayList Konstruktor scheint das zu widerlegen.
```
/**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    super();
    this.elementData = EMPTY_DEFAULTCAPACITY_EMPTY_ELEMENTDATA; //= static, empty
}
```
Aber es nicht schaffen ein element-array der Länge 10, sofort, sondern, wenn Sie Elemente hinzufügen oder sicherzustellen, dass die Kapazität:
```
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        //any size if not default element table
        ? 0
        //larger than default for default empty table. It's already
        //supposed to be at default size.
        : DEFAULT_CAPACITY; //= 10

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}
```
- Vielen Dank, jetzt sehe ich. Ich würde auch hinzufügen, dass diese Logik ähnelt der lazy loading - erstellen nicht-leeres array beim ersten Zugriff.
- Ich denke im 2. Fall Kapazität beginnt bei 10, nicht von 0. "ArrayList(): erstellt eine leere Liste mit einer anfänglichen Kapazität von zehn." Nicht zu reden von der static array!? Wo hast du es bekommen?
- aber ist es nicht sinnvoll zu verwenden new ArrayList(0) da es ein array erstellt wird, die nie verwendet werden
- Ich nicht zu erwähnen Fähigkeit. Was meinst du mit Kapazität beginnt bei 10?
- es erstellt ein array mit Größe 0 und das 1. mal, fügen Sie mindestens ein Element in der ArrayList ist, wird es weggeworfen und ein neues array zugewiesen.
- ja, dass ist Fall 1. In Fall 2 es nutzt DEFAULTCAPACITY_EMPTY_ELEMENTDATA die statische (Blick auf die Quelle). Die Kapazität der Schrittweite kann auch anders, wenn Elemente Hinzugefügt oder Kapazität gewährleistet ist.
- Ich bin damit einverstanden. Wenn ich mit new ArrayList() werden es zeigen zu internen EMPTY_ELEMENTDATA, und sobald es fügt element erstelle ich ein neues array und beginnen mit dem letzten. Im Fall von new ArrayList(0) es wird erstellen eines neuen leeren array-von Anfang an und wird dann neu erstellen, wenn neues element Hinzugefügt wurde. Bin ich im Recht ?
- du hast Recht, die Dokumentation ist nicht up-to-date mit dem code!
InformationsquelleAutor wero
7

Ist es notwendig zu klären, zwei Definitionen:

Den Größe repräsentieren die Anzahl der Elemente in der Liste.

Den Kapazität stellen Sie die Länge der internen array. In anderen Worten, die Länge enthält die Anzahl der Orte, die ein element;

Liste size = 2

Wenn Sie erstellen eine Liste mit den default-Konstruktor von Arraylist:

Ex:
```
List<String> list = new ArrayList<>();
System.out.println(l.size());
```
Die Ausgabe ist : 0

Warum?

Weil die Liste leer ist, dies erklärt sich durch das interne array der Liste, wenn Sie den Standard-Konstruktor von ArrayList, wird der interne array ist :
```
private static final Object[] EMPTY_ELEMENTDATA = {}; 
```
So, wird ein leeres array von Objekten, in denen der Wert der Länge ist 0 (Kapazität). Da die Liste leer ist die Größe 0 ist.

(id elementData=27)

, Wenn Sie fügen Sie ein element in der Liste, die Größe der Liste wird um 1 erhöht, und der anfängliche interne array der Liste wird geändert, von einem anderen array mit einer Länge von 10 (Kapazität); (id elementData=30)
```
private static final int DEFAULT_CAPACITY = 10
```
(id elementData=30)

Über den default-Konstruktor von ArrayList die java-API sagt :
API-Java : https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html#ArrayList%28%29
```
public ArrayList()

Constructs an empty list with an initial capacity of ten.
```
In anderen Worten, dieser Konstruktor erstellt eine leere Liste (die Größe ist gleich 0), mit einer anfänglichen Kapazität von zehn Elementen.(Nach dem hinzufügen eines Elements zu der Liste, die Kapazität der Liste werden 10)

Wenn Sie wissen, die Größe Ihrer Liste, sollten Sie erstellen Sie Ihre Liste mit dieser Größe. Warum? weil die Komplexität der Methode add (E element) ist O(1) amortisiert (wenn genügend Raum vorhanden ist, in Ihrer Liste), aber O(n) (worst-case), wenn Sie mehr Elemente als die ursprüngliche Kapazität der Liste, in diesem Fall ein neues array (1,5-fache Größe) zugeordnet ist, und das alte array wird für die neue kopiert. Klar, diese operation hat Kosten, die in Bezug auf performance-und Speicher-Ressourcen.

So erstellen Sie eine Liste mit einer anfänglichen Kapazität von 0 hat keinen Sinn. Wenn Sie nicht wissen, die erste Fähigkeit deiner Liste, verwenden Sie die Standard-Konstruktor, geben Sie eine Liste mit einer anfänglichen Kapazität von zehn Elementen.

Beachten, dass die Definitionen von Größe und Kapazität, um der ArrayList sind differents:

Aus dem Buch Core Java 2: Grundlagen

Zuweisung einer array-Liste as new ArrayList <'Mitarbeiter>(100) //
die Kapazität ist 100

ist nicht das gleiche wie die Zuweisung ein neues array als neue Mitarbeiter[100] //Größe 100

Es ist ein wichtiger Unterschied zwischen der Kapazität, die ein array-Liste und die Größe eines Arrays. Wenn Sie reservieren ein array mit 100
Einträge, dann das array hat 100 slots, bereit für den Einsatz. Ein array-Liste
mit einer Kapazität von 100 Elemente, die das Potenzial hat, zu halten-100
Elemente (und, in der Tat, mehr als 100, auf die Kosten von zusätzlichen
Umschichtungen); aber am Anfang, auch nach der ersten
Bau, eine array-Liste enthält keine Elemente überhaupt.

InformationsquelleAutor Jesus Zavarce
1

ArrayList hat 2 Konstruktoren. Der default-Konstruktor ruft einfach nur den anderen mit Kapazität=10:
```
ArrayList() {this(10);}

ArrayList(capacity)
```
Was Kapazität bedeutet? Es bedeutet, dass ein array der Größe Kapazität zugewiesen ist, halten Sie die Elemente in der arraylist. Wenn es zu klein, um die notwendigen Elemente, es wird in der Größe verändert werden, indem ein größeres array und kopieren über alles (dauert), + es bedeutet, dass die alte array muss eine garbage Collection ausgeführt werden (noch mehr Zeit). Deshalb ist es wichtig, auf die richtige Kapazität Recht. Obwohl es werden, mit einer anfänglichen Kapazität, es kann langsam sein. Auf der anderen Seite haben große Kapazität, und fast keine Artikel in der es ist, Speicher zu verschwenden.

Hinweis: Arraylist(0) erstellen Sie eine Größe 0-array, und wenn Sie versuchen, fügen Sie das 1. element ist, wird es weggeworfen und ein neues array zugewiesen.
- Welche Java-version?
InformationsquelleAutor Gavriel
1

ArrayList() wird die Liste mit einer Kapazität von 10 (default) nach dem ersten element Hinzugefügt. Allerdings ArrayList(0) wird halten Kapazität klein - es wird 1 nach dem ersten element Hinzugefügt, 2 nach dem zweiten hinzufügen, und etc.

InformationsquelleAutor Ruslanas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.