TOC

Anleitung zur Java ArrayList

Anleitung zur Java ArrayList

1. Überblick

In diesem Artikel werfen wir einen Blick auf die KlasseArrayListaus dem Java Collections Framework. Wir werden seine Eigenschaften, häufige Anwendungsfälle sowie seine Vor- und Nachteile diskutieren.

ArrayList befindet sich in Java Core Libraries, sodass Sie keine zusätzlichen Bibliotheken benötigen. Um es zu benutzen, fügen Sie einfach die folgende Import-Anweisung hinzu: 

import java.util.ArrayList;

List repräsentiert eine geordnete Folge von Werten, bei denen ein Wert mehr als einmal auftreten kann.

ArrayList ist eine der auf einem Array erstelltenList-Implementierungen, die beim Hinzufügen / Entfernen von Elementen dynamisch wachsen und verkleinern können. Auf Elemente kann leicht über ihre Indizes zugegriffen werden, die bei Null beginnen. Diese Implementierung hat die folgenden Eigenschaften:

  • Der wahlfreie Zugriff dauertO(1)

  • Das Hinzufügen eines Elements dauert amortisierte konstante ZeitO(1)

  • Inserting/Deleting takes O(n) time

  • Die Suche dauertO(n) Zeit für ein unsortiertes Array undO(log n) für ein sortiertes Array

2. Erstellen Sie einArrayList

ArrayList hat mehrere Konstruktoren und wir werden sie alle in diesem Abschnitt vorstellen.

Beachten Sie zunächst, dassArrayList eine generische Klasse ist, sodass Sie sie mit einem beliebigen Typ parametrisieren können und der Compiler sicherstellt, dass Sie beispielsweise keineInteger-Werte in eine Sammlung einfügen können vonStrings. Außerdem müssen Sie keine Elemente umwandeln, wenn Sie sie aus einer Sammlung abrufen.

Zweitens empfiehlt es sich, die generische SchnittstelleList als Variablentyp zu verwenden, da sie von einer bestimmten Implementierung entkoppelt wird.

2.1. Standard-No-Arg-Konstruktor 

List list = new ArrayList<>();
assertTrue(list.isEmpty());

Wir erstellen einfach eine leereArrayList-Instanz.

2.2. Konstruktor, der die Anfangskapazität akzeptiert 

List list = new ArrayList<>(20);

Hier geben Sie die Anfangslänge eines zugrunde liegenden Arrays an. Dies kann Ihnen helfen, unnötige Größenänderungen beim Hinzufügen neuer Elemente zu vermeiden.

2.3. Konstruktor, derCollection akzeptiert 

Collection number
  = IntStream.range(0, 10).boxed().collect(toSet());

List list = new ArrayList<>(numbers);
assertEquals(10, list.size());
assertTrue(numbers.containsAll(list));

Beachten Sie, dass das Element der Instanz vonCollectionzum Auffüllen des zugrunde liegenden Arrays verwendet wird.

3. Fügen Sie denArrayList Elemente hinzu

Sie können ein Element entweder am Ende oder an einer bestimmten Position einfügen: 

List list = new ArrayList<>();

list.add(1L);
list.add(2L);
list.add(1, 3L);

assertThat(Arrays.asList(1L, 3L, 2L), equalTo(list));

Sie können auch eine Sammlung oder mehrere Elemente gleichzeitig einfügen: 

List list = new ArrayList<>(Arrays.asList(1L, 2L, 3L));
LongStream.range(4, 10).boxed()
  .collect(collectingAndThen(toCollection(ArrayList::new), ys -> list.addAll(0, ys)));
assertThat(Arrays.asList(4L, 5L, 6L, 7L, 8L, 9L, 1L, 2L, 3L), equalTo(list));

4. Iterieren Sie überArrayList

Es stehen zwei Arten von Iteratoren zur Verfügung:Iterator undListIterator.

Während der erste die Möglichkeit bietet, die Liste in eine Richtung zu durchlaufen, können Sie mit dem zweiten die Liste in beide Richtungen durchlaufen.

Hier zeigen wir Ihnen nur dieListIterator: 

List list = new ArrayList<>(
  IntStream.range(0, 10).boxed().collect(toCollection(ArrayList::new))
);
ListIterator it = list.listIterator(list.size());
List result = new ArrayList<>(list.size());
while (it.hasPrevious()) {
    result.add(it.previous());
}

Collections.reverse(list);
assertThat(result, equalTo(list));

Sie können Elemente auch mithilfe von Iteratoren suchen, hinzufügen oder entfernen.

5. Suchen Sie dieArrayList

Wir werden zeigen, wie die Suche mithilfe einer Sammlung funktioniert: 

List list = LongStream.range(0, 16)
  .boxed()
  .map(Long::toHexString)
  .collect(toCollection(ArrayList::new));
List stringsToSearch = new ArrayList<>(list);
stringsToSearch.addAll(list);

5.1. Durchsuchen einer unsortierten Liste

Um ein Element zu finden, können Sie die MethodenindexOf() oderlastIndexOf() verwenden. Beide akzeptieren ein Objekt und geben den Wert vonintzurück: 

assertEquals(10, stringsToSearch.indexOf("a"));
assertEquals(26, stringsToSearch.lastIndexOf("a"));

Wenn Sie alle Elemente finden möchten, die ein Prädikat erfüllen, können Sie die Sammlung mit Java 8Stream API (lesen Sie mehr darüberhere) mitPredicate wie folgt filtern: 

Set matchingStrings = new HashSet<>(Arrays.asList("a", "c", "9"));

List result = stringsToSearch
  .stream()
  .filter(matchingStrings::contains)
  .collect(toCollection(ArrayList::new));

assertEquals(6, result.size());

Es ist auch möglich, einefor-Schleife oder einen Iterator zu verwenden: 

Iterator it = stringsToSearch.iterator();
Set matchingStrings = new HashSet<>(Arrays.asList("a", "c", "9"));

List result = new ArrayList<>();
while (it.hasNext()) {
    String s = it.next();
    if (matchingStrings.contains(s)) {
        result.add(s);
    }
}

5.2. Durchsuchen einer sortierten Liste

Wenn Sie ein sortiertes Array haben, können Sie einen binären Suchalgorithmus verwenden, der schneller als die lineare Suche funktioniert: 

List copy = new ArrayList<>(stringsToSearch);
Collections.sort(copy);
int index = Collections.binarySearch(copy, "f");
assertThat(index, not(equalTo(-1)));

Beachten Sie, dass -1 zurückgegeben wird, wenn ein Element nicht gefunden wird.

6. Entfernen Sie Elemente ausArrayList

Um ein Element zu entfernen, sollten Sie seinen Index finden und erst dann die Entfernung über die Methoderemove()durchführen. Eine überladene Version dieser Methode, die ein Objekt akzeptiert, danach sucht und das erste Auftreten eines gleichen Elements entfernt: 

List list = new ArrayList<>(
  IntStream.range(0, 10).boxed().collect(toCollection(ArrayList::new))
);
Collections.reverse(list);

list.remove(0);
assertThat(list.get(0), equalTo(8));

list.remove(Integer.valueOf(0));
assertFalse(list.contains(0));

Seien Sie jedoch vorsichtig, wenn Sie mit Box-Typen wieInteger arbeiten. Um ein bestimmtes Element zu entfernen, sollten Sie zuerst den Wert voninteingeben. Andernfalls wird ein Element durch seinen Index entfernt.

Sie können auch die oben genanntenStream API zum Entfernen mehrerer Elemente verwenden, wir werden sie hier jedoch nicht anzeigen. Zu diesem Zweck verwenden wir einen Iterator: 

Set matchingStrings
 = HashSet<>(Arrays.asList("a", "b", "c", "d", "e", "f"));

Iterator it = stringsToSearch.iterator();
while (it.hasNext()) {
    if (matchingStrings.contains(it.next())) {
        it.remove();
    }
}

7. Zusammenfassung

In diesem kurzen Artikel haben wir uns die ArrayList in Java angesehen.

Wir haben gezeigt, wie man eineArrayList-Instanz erstellt, wie man Elemente mit verschiedenen Ansätzen hinzufügt, findet oder entfernt.

Wie üblich finden Sie alle Codebeispieleover on GitHub.

Related