Das letzte Element aus einer ArrayList in Java abrufen

1. Letztes Element mit den Methoden size() und get() abrufen
2. Konvertieren Sie ArrayList in LinkedList in Java
3. Konvertieren Sie ArrayList in ArrayDeque in Java
4. Benutzung der Guavenbibliothek
5. Zusammenfassung

Dieses Tutorial stellt vor, wie man das letzte Element aus einer ArrayList in Java erhält, und listet auch einige Beispielcodes auf, um das Thema zu verstehen.

Eine ArrayList ist ein dynamisches Array, das verwendet werden kann, um ähnliche Daten in einer geordneten Sammlung zu speichern. Eine großartige Sache an Arrays und ArrayList ist, dass sie wahlfreien Zugriff auf jedes darin gespeicherte Element ermöglichen, vorausgesetzt, wir kennen den Index, in dem es gespeichert ist. Aber wie können wir auf das letzte Element einer ArrayList zugreifen, wenn wir ihren Index nicht kennen? Einige andere Sprachen wie Python bieten eine umgekehrte Indizierung, sodass wir mit -1 auf das letzte Element zugreifen können. In diesem Tutorial erfahren Sie, wie Sie das letzte Element aus einer ArrayList in Java abrufen.

Letztes Element mit den Methoden size() und get() abrufen

Eine ArrayList in Java hat die Methode size(), mit der man die Anzahl der Elemente ermitteln kann, die in der ArrayList vorhanden sind.

import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    System.out.printf("The list contains %d elements", list.size());
  }
}

Ausgabe:

The list contains 5 elements

Wir wissen, dass der letzte Index einer ArrayList um eins kleiner ist als seine Länge (weil er einer nullbasierten Indizierung folgt). Wir können diese Informationen verwenden, um das letzte Element abzurufen. Wir verwenden die Methode get() von ArrayList, um das letzte Element zu erhalten.

import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    int lastIdx = list.size() - 1;
    int lastElement = list.get(lastIdx);
    System.out.println("The last index of list is: " + lastIdx);
    System.out.print("The last element of list is: " + lastElement);
  }
}

Ausgabe:

The last index of list is: 4The last element of list is: 25

Lassen Sie uns eine generische Methode schreiben, um zu vermeiden, dass Sie immer wieder dieselbe Logik schreiben.

import java.util.ArrayList;
public class LastElement {
  public static <E> E getLastElement(ArrayList<E> list) {
    int lastIdx = list.size() - 1;
    E lastElement = list.get(lastIdx);
    return lastElement;
  }
  public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    list1.add(5);
    list1.add(10);
    list1.add(15);
    list1.add(20);
    list1.add(25);
    ArrayList<String> list2 = new ArrayList<String>();
    list2.add("1");
    list2.add("2");
    list2.add("3");
    System.out.println("The last element of list1 is: " + getLastElement(list1));
    System.out.print("The last element of list2 is: " + getLastElement(list2));
  }
}

Ausgabe:

The last element of list1 is: 25
The last element of list2 is: 3

Was passiert, wenn wir unsere Methode auf einer leeren ArrayList ausführen? Wir erhalten eine IndexOutOfBoundsException, wenn wir den obigen Code auf einer leeren Liste ausführen. Dies geschieht, weil die Methode size() Null für eine leere ArrayList zurückgibt und wenn wir 1 davon subtrahieren, erhalten wir -1 als Index. Es gibt keinen negativen Index. Im folgenden Beispiel wird diese Ausnahme zurückgegeben.

import java.util.ArrayList;
public class LastElement {
  public static <E> E getLastElement(ArrayList<E> list) {
    int lastIdx = list.size() - 1;
    E lastElement = list.get(lastIdx);
    return lastElement;
  }
  public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    System.out.println("The last element of list1 is: " + getLastElement(list1));
  }
}

Lassen Sie uns einige Bedingungen überprüfen, bevor wir die Methode size() ausführen. Wir verwenden die Methode isEmpty(), um zu überprüfen, ob die Liste leer ist.

import java.util.ArrayList;
public class LastElement {
  public static <E> E getLastElement(ArrayList<E> list) {
    if ((list != null) && (list.isEmpty() == false)) {
      int lastIdx = list.size() - 1;
      E lastElement = list.get(lastIdx);
      return lastElement;
    } else
      return null;
  }
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    System.out.println("The last element of list is: " + getLastElement(list));
  }
}

Ausgabe:

The last element of list is: null

Konvertieren Sie ArrayList in LinkedList in Java

Die Klasse LinkedList implementiert ebenso wie ArrayList die Schnittstelle List. Die Klasse LinkedList verfügt über eine einfache Methode getLast(), mit der das letzte Element der Liste geholt werden kann.

Wenn wir unsere ArrayList in eine LinkedList umwandeln können, dann können wir diese Methode verwenden. Dieser Vorgang wird unsere ursprüngliche ArrayList nicht verändern.

import java.util.ArrayList;
import java.util.LinkedList public class LastElement {
  public static <E> E getLastElementUsingLinkedList(ArrayList<E> arrList) {
    LinkedList<E> linkedList = new LinkedList<E>(arrList);
    return linkedList.getLast();
  }
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    System.out.println("The last element of list is: " + getLastElementUsingLinkedList(list));
    System.out.print("The array list is: " + list);
  }
}

Ausgabe:

The last element of list is: 25
The array list is: [5, 10, 15, 20, 25]

Die obige Lösung ist keine elegante Möglichkeit, das letzte Element zu erhalten, und wird nicht empfohlen. Wenn wir mehrmals auf das letzte Element zugreifen müssen, wird empfohlen, LinkedList (oder eine andere Sammlung) anstelle von ArrayList zu verwenden.

Konvertieren Sie ArrayList in ArrayDeque in Java

Eine Deque ist eine doppelseitige Warteschlange. Ein ArrayDeque kombiniert die veränderbaren Array-Funktionalitäten mit der Deque-Datenstruktur. Genau wie LinkedList verfügt ArrayDeque auch über eine praktische getLast()-Methode, die verwendet werden kann, um das letzte Element des Deque anzuzeigen. Wir müssen lediglich unsere ArrayList in ein ArrayDeque konvertieren, um diese Methode zu verwenden.

import java.util.ArrayDeque;
import java.util.ArrayList;
public class LastElement {
  public static <E> Object getLastElementUsingArrayDeque(ArrayList<E> arrList) {
    ArrayDeque<E> deque = new ArrayDeque<E>(arrList);
    return deque.getLast();
  }
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    System.out.println("The last element of list is: " + getLastElementUsingArrayDeque(list));
    System.out.print("The array list is: " + list);
  }
}

Auch diese Methode ist nicht sehr elegant und wenn wir mehrmals auf das letzte Element zugreifen müssen, wird empfohlen, ArrayDeque anstelle einer ArrayList zu verwenden.

Benutzung der Guavenbibliothek

Die Google Guava-Bibliothek bietet eine einfache Methode zum Abrufen des letzten Elements aus einer ArrayList. Wir verwenden die Methode getLast() der Klasse Iterables dieser Bibliothek, um das letzte Element zu erhalten. Stellen Sie sicher, dass Sie diese Bibliothek herunterladen und Ihrem Projekt hinzufügen, bevor Sie den folgenden Code ausführen.

import com.google.common.collect.Iterables;
import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    Integer lastEle = Iterables.getLast(list);
    System.out.print("The last element of the array list is: " + lastEle);
  }
}

Ausgabe:

The last element of the array list is: 25

Wir können der Methode getLast() auch einen Standardwert zur Verfügung stellen, der angezeigt wird, wenn die Liste leer ist. Dadurch wird verhindert, dass Java Ausnahmen auslöst.

import com.google.common.collect.Iterables;
import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<String>();
    String lastEle = Iterables.getLast(list, "No Element Found"); // No Element Found is the
                                                                  // default value
    System.out.print("The last element of the array list is: " + lastEle);
  }
}

Ausgabe:

The last element of the array list is: No Element Found

Zusammenfassung

Eine ArrayList ist eine sehr verbreitete Datenstruktur, die meist verwendet wird, um das Problem normaler Arrays auf begrenzter Größe zu beseitigen. In vielen Fällen kennen wir den letzten Index der Liste möglicherweise nicht, sodass wir das letzte darin gespeicherte Element nicht finden können.

Wir können die Methoden size() und get() verwenden, um dieses Element anzuzeigen. Die Google Guava-Bibliothek bietet auch eine einfache Möglichkeit, das letzte Element abzurufen.

Wenn wir häufig auf das letzte Element zugreifen müssen, verwenden Sie vorzugsweise eine andere Sammlung wie LinkedList oder ArrayDeque, da diese Sammlungen über die erforderlichen Methoden verfügen.