Come posso ottenere l'ultimo valore di una ArrayList?

Non conosco l'ultimo indice di ArrayList.

Quanto segue fa parte Listdell'interfaccia (che ArrayList implementa):

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

Eè il tipo di elemento. Se l'elenco è vuoto, getgenera un IndexOutOfBoundsException. Puoi trovare l'intera documentazione API qui .

Non esiste un modo elegante in vaniglia Java.

Google Guava

La libreria di Google Guava è fantastica: dai un'occhiata alla loro Iterablesclasse . Questo metodo genererà un NoSuchElementExceptionse l'elenco è vuoto, al contrario di un IndexOutOfBoundsException, come con l' size()-1approccio tipico - trovo NoSuchElementExceptionmolto più bello, o la possibilità di specificare un valore predefinito:

lastElement = Iterables.getLast(iterableList);

Puoi anche fornire un valore predefinito se l'elenco è vuoto, anziché un'eccezione:

lastElement = Iterables.getLast(iterableList, null);

oppure, se stai usando Opzioni:

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

questo dovrebbe farlo:

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

Uso la classe micro-util per ottenere l'ultimo (e primo) elemento dell'elenco:

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

Leggermente più flessibile:

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

Il size()metodo restituisce il numero di elementi in ArrayList. I valori dell'indice degli elementi sono 0passati (size()-1), quindi dovresti usare myArrayList.get(myArrayList.size()-1)per recuperare l'ultimo elemento.

Usando lambdas:

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

Non esiste un modo elegante per ottenere l'ultimo elemento di un elenco in Java (rispetto ad esempio items[-1]in Python).

Devi usare list.get(list.size()-1).

Quando si lavora con elenchi ottenuti da chiamate di metodo complicate, la soluzione alternativa risiede nella variabile temporanea:

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

Questa è l'unica opzione per evitare la versione brutta e spesso costosa o addirittura non funzionante:

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

Sarebbe bello se la correzione di questo difetto di progettazione fosse introdotta nell'API Java.

Se puoi, scambia il ArrayListcon un ArrayDeque, che ha metodi convenienti come removeLast.

Come indicato nella soluzione, se Listè vuoto, IndexOutOfBoundsExceptionviene lanciato un. Una soluzione migliore è utilizzare il Optionaltipo:

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

Come prevedibile, l'ultimo elemento dell'elenco viene restituito come Optional:

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

Si occupa anche con grazia di elenchi vuoti:

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

Se invece usi una LinkedList, puoi accedere al primo elemento e all'ultimo con solo getFirst()e getLast()(se vuoi un modo più pulito di size () -1 e get (0))

Implementazione

Dichiara un LinkedList

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

Quindi questi sono i metodi che puoi usare per ottenere quello che vuoi, in questo caso stiamo parlando dell'elemento FIRST e LAST di un elenco

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

Quindi, allora puoi usare

mLinkedList.getLast(); 

per ottenere l'ultimo elemento dell'elenco.

guava fornisce un altro modo per ottenere l'ultimo elemento da un List:

last = Lists.reverse(list).get(0)

se l'elenco fornito è vuoto, genera un IndexOutOfBoundsException

Poiché l'indicizzazione in ArrayList inizia da 0 e termina di una posizione prima della dimensione effettiva, quindi l'istruzione corretta per restituire l'ultimo elemento dell'arraylist sarebbe:

int last = mylist.get (mylist.size () - 1);

Per esempio:

se la dimensione dell'elenco di array è 5, allora size-1 = 4 restituirà l'ultimo elemento dell'array.

L'ultimo elemento nell'elenco è list.size() - 1. La raccolta è supportata da una matrice e le matrici iniziano dall'indice 0.

Quindi l'elemento 1 nell'elenco è all'indice 0 dell'array

L'elemento 2 nell'elenco è nell'indice 1 dell'array

L'elemento 3 nell'elenco è nell'indice 2 dell'array

e così via..

Che ne dici di questo ... Da qualche parte nella tua classe ...

List<E> list = new ArrayList<E>();
private int i = -1;
    public void addObjToList(E elt){
        i++;
        list.add(elt);
    }


    public E getObjFromList(){
        if(i == -1){ 
            //If list is empty handle the way you would like to... I am returning a null object
            return null; // or throw an exception
        }

        E object = list.get(i);
        list.remove(i); //Optional - makes list work like a stack
        i--;            //Optional - makes list work like a stack
        return object;
    }

Se modifichi la tua lista, usa listIterator()e itera dall'ultimo indice (cioè size()-1rispettivamente). Se fallisci di nuovo, controlla la struttura della tua lista.

Tutto quello che devi fare è usare size () per ottenere l'ultimo valore dell'Arraylist. Per es. se sei ArrayList di numeri interi, allora per ottenere l'ultimo valore dovrai

int lastValue = arrList.get(arrList.size()-1);

Ricorda, è possibile accedere agli elementi di un Arraylist usando i valori dell'indice. Pertanto, gli array sono generalmente utilizzati per cercare elementi.

le matrici memorizzano le loro dimensioni in una variabile locale chiamata 'lunghezza'. Dato un array chiamato "a", è possibile utilizzare quanto segue per fare riferimento all'ultimo indice senza conoscere il valore dell'indice

un [a.length-1]

per assegnare un valore di 5 a questo ultimo indice dovresti usare:

un [a.length-1] = 5;

Alternativa usando l'API Stream:

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

Risultati in un facoltativo dell'ultimo elemento.

In Kotlin, puoi usare il metodo last:

val lastItem = list.last()