webentwicklung-frage-antwort-db.com.de

So erhalten Sie den letzten Wert einer ArrayList

Wie kann ich den letzten Wert einer ArrayList erhalten?

Ich kenne den letzten Index der ArrayList nicht.

480
Jessy

Das Folgende ist Teil der List -Schnittstelle (die ArrayList implementiert):

E e = list.get(list.size() - 1);

E ist der Elementtyp. Wenn die Liste leer ist, wirft get eine IndexOutOfBoundsException . Die gesamte API-Dokumentation finden Sie hier .

563

das sollte es tun:

if (arrayList != null && !arrayList.isEmpty()) {
  T item = arrayList.get(arrayList.size()-1);
}
177
Henrik Paul

Es gibt keinen eleganten Weg in Vanilla Java.

Google Guava

Die Google Guava - Bibliothek ist großartig - überprüfen Sie ihre Iterables Klasse . Diese Methode wirft ein NoSuchElementException , wenn die Liste leer ist, im Gegensatz zu einem IndexOutOfBoundsException , wie bei dem typischen size()-1-Ansatz - ich finde einen NoSuchElementException -Zweig netter oder die Möglichkeit, einen Standard festzulegen:

lastElement = Iterables.getLast(iterableList);

Sie können anstelle einer Ausnahme auch einen Standardwert angeben, wenn die Liste leer ist:

lastElement = Iterables.getLast(iterableList, null);

oder, wenn Sie Optionen verwenden:

lastElementRaw = Iterables.getLast(iterableList, null);
lastElement = (lastElementRaw == null) ? Option.none() : Option.some(lastElementRaw);
176
Antony Stubbs

Ich verwende die Klasse micro-util, um das letzte (und erste) Element der Liste zu erhalten:

public final class Lists {

    private Lists() {
    }

    public static <T> T getFirst(List<T> list) {
        return list != null && !list.isEmpty() ? list.get(0) : null;
    }

    public static <T> T getLast(List<T> list) {
        return list != null && !list.isEmpty() ? list.get(list.size() - 1) : null;
    }
}

Etwas flexibler:

import Java.util.List;

/**
 * Convenience class that provides a clearer API for obtaining list elements.
 */
public final class Lists {

  private Lists() {
  }

  /**
   * Returns the first item in the given list, or null if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a first item.
   *
   * @return null if the list is null or there is no first item.
   */
  public static <T> T getFirst( final List<T> list ) {
    return getFirst( list, null );
  }

  /**
   * Returns the last item in the given list, or null if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a last item.
   *
   * @return null if the list is null or there is no last item.
   */
  public static <T> T getLast( final List<T> list ) {
    return getLast( list, null );
  }

  /**
   * Returns the first item in the given list, or t if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a first item.
   * @param t The default return value.
   *
   * @return null if the list is null or there is no first item.
   */
  public static <T> T getFirst( final List<T> list, final T t ) {
    return isEmpty( list ) ? t : list.get( 0 );
  }

  /**
   * Returns the last item in the given list, or t if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a last item.
   * @param t The default return value.
   *
   * @return null if the list is null or there is no last item.
   */
  public static <T> T getLast( final List<T> list, final T t ) {
    return isEmpty( list ) ? t : list.get( list.size() - 1 );
  }

  /**
   * Returns true if the given list is null or empty.
   *
   * @param <T> The generic list type.
   * @param list The list that has a last item.
   *
   * @return true The list is empty.
   */
  public static <T> boolean isEmpty( final List<T> list ) {
    return list == null || list.isEmpty();
  }
}
24
user11153

Die size()-Methode gibt die Anzahl der Elemente in der ArrayList zurück. Die Indexwerte der Elemente lauten 0 bis (size()-1), sodass Sie mit myArrayList.get(myArrayList.size()-1) das letzte Element abrufen.

10
Ken Paul

Mit Lambdas:

Function<ArrayList<T>, T> getLast = a -> a.get(a.size() - 1);
5

Falls möglich, tauschen Sie ArrayList gegen einen ArrayDeque aus, der über praktische Methoden wie removeLast verfügt.

4
John Glassmyer
            Let ArrayList is myList

            public void getLastValue(List myList){
            // Check ArrayList is null or Empty
            if(myList == null || myList.isEmpty()){
                return;
            }

            // check size of arrayList
            int size = myList.size();


    // Since get method of Arraylist throws IndexOutOfBoundsException if index >= size of arrayList. And in arraylist item inserts from 0th index.
    //So please take care that last index will be (size of arrayList - 1)
            System.out.print("last value := "+myList.get(size-1));
        }
1
Alok Mishra

Wie in der Lösung angegeben, wird eine List geworfen, wenn die IndexOutOfBoundsException leer ist. Eine bessere Lösung ist die Verwendung des Typs Optional:

public class ListUtils {
    public static <T> Optional<T> last(List<T> list) {
        return list.isEmpty() ? Optional.empty() : Optional.of(list.get(list.size() - 1));
    }
}

Wie zu erwarten, wird das letzte Element der Liste als Optional zurückgegeben:

var list = List.of(10, 20, 30);
assert ListUtils.last(list).orElse(-1) == 30;

Es wird auch elegant mit leeren Listen umgegangen:

var emptyList = List.<Integer>of();
assert ListUtils.last(emptyList).orElse(-1) == -1;
1
Colin Breame

Wenn Sie stattdessen eine LinkedList verwenden, können Sie mit getFirst() und getLast() auf das erste und das letzte Element zugreifen (wenn Sie einen saubereren Weg als size () -1 und get (0)) möchten.

Implementierung

Deklarieren Sie eine LinkedList

LinkedList<Object> mLinkedList = new LinkedList<>();

Dies sind die Methoden, die Sie verwenden können, um das zu erhalten, was Sie möchten. In diesem Fall sprechen wir überFIRSTundLASTElement einer Liste

/**
     * Returns the first element in this list.
     *
     * @return the first element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

    /**
     * Returns the last element in this list.
     *
     * @return the last element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

    /**
     * Removes and returns the first element from this list.
     *
     * @return the first element from this list
     * @throws NoSuchElementException if this list is empty
     */
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

    /**
     * Removes and returns the last element from this list.
     *
     * @return the last element from this list
     * @throws NoSuchElementException if this list is empty
     */
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

    /**
     * Inserts the specified element at the beginning of this list.
     *
     * @param e the element to add
     */
    public void addFirst(E e) {
        linkFirst(e);
    }

    /**
     * Appends the specified element to the end of this list.
     *
     * <p>This method is equivalent to {@link #add}.
     *
     * @param e the element to add
     */
    public void addLast(E e) {
        linkLast(e);
    }

So können Sie dann verwenden 

mLinkedList.getLast(); 

um das letzte Element der Liste zu erhalten.

0

Alternative unter Verwendung der Stream-API:

list.stream().reduce((first, second) -> second)

Ergebnisse in einem optionalen Element des letzten Elements.

0
Terran

Der letzte Eintrag in der Liste ist list.size() - 1. Die Auflistung wird von einem Array unterstützt und Arrays beginnen bei Index 0.

Das Element 1 in der Liste hat also den Index 0 im Array 

Element 2 in der Liste befindet sich auf Index 1 im Array

Element 3 in der Liste befindet sich an Index 2 im Array 

und so weiter..

0
MircoProgram

Es gibt keine elegante Möglichkeit, das letzte Element einer Liste in Java abzurufen (im Vergleich zu beispielsweise items[-1] in Python).

Sie müssen list.get(list.size()-1) verwenden.

Bei der Arbeit mit Listen, die durch komplizierte Methodenaufrufe erhalten wurden, liegt die Problemumgehung in einer temporären Variablen:

List<E> list = someObject.someMethod(someArgument, anotherObject.anotherMethod());
return list.get(list.size()-1);

Dies ist die einzige Möglichkeit, um hässliche und oft teure oder gar nicht funktionierende Versionen zu vermeiden:

return someObject.someMethod(someArgument, anotherObject.anotherMethod()).get(
    someObject.someMethod(someArgument, anotherObject.anotherMethod()).size() - 1
);

Es wäre schön, wenn eine Korrektur für diesen Konstruktionsfehler in die Java-API eingeführt würde.

0
Tregoreg