Vorteile der Arrayliste (schnelle Abfrage, langsames Hinzufügen und Löschen)
Nachteile von ArrayList (langsames Hinzufügen und Löschen, schnelle Abfrage)
Tatsächlich ist es relativ einfach, diese beiden Punkte zu verstehen, dh um die Datenstruktur (ein Verständnis des Arrays) zu verstehen , hat jede Datenstruktur ihre eigene zeitliche und räumliche Komplexität , was bedeutet, dass das Effizienzproblem ähnlich zu O (1) ist. O (n), O (logn) Dies ist die Komplexität, und es gibt auch die Ebene der Java-Implementierung . In diesem Artikel werden Effizienz- und Leistungsprobleme auf diesen Ebenen behandelt
Der erste Teil: Array (Datenstruktur)
Es wird im Buch Datenstruktur erwähnt: Array kann als erweiterte lineare Datenstruktur betrachtet werden. Seine Besonderheit spiegelt sich nicht in der Funktionsweise von Datenelementen wie Stapeln und Warteschlangen wider, sondern in der Zusammensetzung von Datenelementen auf. Aus der Perspektive der Elemente, aus denen die lineare Tabelle besteht, weist das Array eine bestimmte Struktur von Datenelementen auf, und das Array ist die Erweiterung der linearen Tabelle.
Näher Zuhause:
Array ist eine Datenstruktur, mit der wir alle sehr vertraut sind, und Hochsprachen unterstützen diesen Datentyp im Allgemeinen.
Das Array ist eine lineare Tabelle , dh die Struktur der Datenleitung ist wie eine gerade Linie, mit Ausnahme des Arrays, wie die verknüpfte Liste, die Warteschlange und der Stapel sind alle lineare Strukturen
Die nichtlineare Tabelle ist ein Binärbaum, ein Stapel, eine Zeichnung usw. ist keine einfache Beziehung zwischen den Daten
Die Beziehung zwischen Array und verknüpfter Liste?
Wir antworten normalerweise: Verknüpfte Listen eignen sich zum Einfügen und Löschen, und die zeitliche Komplexität beträgt O (1), Arrays sind für die Suche geeignet und die Komplexität der Suchzeit beträgt O (1).
Tatsächlich ist dieser Ausdruck ungenau. Arrays sind für die Suche geeignet, aber die zeitliche Komplexität der Suche ist nicht O (1). Daher ist der korrekte Ausdruck, dass das Array den Direktzugriff gemäß der folgenden Tabelle (Indexposition) unterstützt Die zeitliche Komplexität ist O (1)
Um bestimmte Datenstruktur-Arrays zu kennen, können Sie bestimmte Bücher durchgehen, um mehr darüber zu erfahren. Die Speicher- und Berechnungsmethoden von Arrays in Computern können alle untersucht und erlernt werden. Für ein gründliches Verständnis des Autors sollten Sie diesen Weg wählen Und das Design wird eine große Hilfe sein und auch helfen zu verstehen, warum wir fragen?
Teil 2: Analyse von der Quellenebene von ArrayList
Ich habe bereits einige Kenntnisse über Arrays gesagt. Jetzt muss ich ein gewisses Verständnis für Arrays haben. Tatsächlich spielt es keine Rolle, ob Sie nicht zu tief verstehen. Es reicht aus, die festen Eigenschaften von Arrays zu kennen. Daher basiert die unterste Ebene der Arrayliste auf Arrays. Wir müssen jetzt verstehen, warum Arraylist schnell hinzufügt und löscht und die Abfrage langsam ist. Analysieren wir dies aus der Perspektive des Quellcodes:
/**
* Returns the element at the specified position in this list.
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
//入参为索引值，也就是下标
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
// Positional Access Operations
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
Der obige Code ist die Quellcode-Implementierung von Arraylist, da die unterste Schicht basierend auf Arrays implementiert ist und die Eigenschaften von Arrays auch schnell Abfragen hinzufügen und löschen können. Jetzt werden Daten direkt basierend auf Indizes erhalten, sodass die zeitliche Komplexität O (1) und Arraylist ist Die RandomAccess-Schnittstelle ist implementiert und der Direktzugriff wird unterstützt. Dies macht deutlich, dass die Abfrageeffizienz sehr schnell ist.
Das Problem des langsamen Hinzufügens und Löschens kann eingehend untersucht werden, und es gibt nicht viel zu sagen: Ein Blick auf den Quellcode kann hilfreich sein, um die Array-Datenstruktur zu verstehen
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
@SuppressWarnings("unchecked")
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);Das Obige sind die Daten zum Hinzufügen von Elementen am Ende des Arrays. Die zeitliche Komplexität hat keine Auswirkung. Es wird nur eine Erweiterungsoperation überprüft (die auch während des Erweiterungsprozesses eine leistungsaufwendige Operation ist). Verwenden Sie ein Bild, um sie anschaulich zu beschreiben:
Wenn Sie es jedoch an der angegebenen Stelle hinzufügen, wirkt sich dies erheblich auf die Leistung aus.
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
//在这一步执行native声明的方法的时候，就是耗费时间和性能的一步操作了，在底层具体的实现方式是这样的
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
Erklären Sie nun, der Grund, warum die Leistung relativ niedrig ist, liegt darin, dass jedes Mal, wenn Sie ein Element hinzufügen, z. B. ein Element an Position 2, das Element nach Position 1 rückwärts verschoben werden muss. Der Bewegungsprozess wirkt sich auf die Leistung aus. Dies ist der obige Code Dieser Schritt des ArrayCopy-Vorgangs in und die Überprüfung der Erweiterung sind ebenfalls vorhanden.
Methode entfernen:
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index + 1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}Wenn Sie sich den obigen Quellcode ansehen, sollte dies sehr klar sein. Dies entspricht der Add-Methode. Im Folgenden wird das dynamische Bild beschrieben:
Jetzt sollten Sie ein gutes Verständnis für das langsame Hinzufügen und Löschen von ArrayList-Abfragen haben. Wenn mit der Beschreibung etwas nicht stimmt, lassen Sie uns gemeinsam sprechen. Möglicherweise ist die Beschreibung der Arrays in diesem Artikel nicht besonders detailliert. Wenn Sie sie nicht verstehen, können Sie sie selbst lernen. Ich werde in Zukunft einige grundlegende Datenstrukturen hinzufügen.