So erhalten Sie den letzten Wert einer ArrayList

das sollte es tun:

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

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);

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();
  }
}

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.

Mit Lambdas:

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

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

            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));
        }

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;

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.

Alternative unter Verwendung der Stream-API:

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

Ergebnisse in einem optionalen Element des letzten Elements.

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..

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.