¿Cómo puedo obtener el último valor de una ArrayList?

No sé el último índice de ArrayList.

Lo siguiente es parte de la Listinterfaz (que implementa ArrayList):

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

Ees el tipo de elemento Si la lista está vacía, getarroja un IndexOutOfBoundsException. Puede encontrar toda la documentación de la API aquí .

No hay una manera elegante en Java vainilla.

Google guayaba

La biblioteca de Google Guava es excelente, echa un vistazo a su Iterablesclase . Este método arrojará un NoSuchElementExceptionsi la lista está vacía, en lugar de un IndexOutOfBoundsException, como con el size()-1enfoque típico : encuentro NoSuchElementExceptionmucho mejor o la capacidad de especificar un valor predeterminado:

lastElement = Iterables.getLast(iterableList);

También puede proporcionar un valor predeterminado si la lista está vacía, en lugar de una excepción:

lastElement = Iterables.getLast(iterableList, null);

o, si está usando Opciones:

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

esto debería hacerlo:

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

Uso la clase micro-util para obtener el último (y primer) elemento de la lista:

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

Ligeramente más flexible:

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

El size()método devuelve el número de elementos en ArrayList. Los valores de índice de los elementos están 0completos (size()-1), por lo que usaría myArrayList.get(myArrayList.size()-1)para recuperar el último elemento.

Usando lambdas:

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

No hay una forma elegante de obtener el último elemento de una lista en Java (en comparación, por ejemplo, items[-1]en Python).

Tienes que usar list.get(list.size()-1).

Cuando se trabaja con listas obtenidas por llamadas a métodos complicados, la solución reside en la variable temporal:

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

Esta es la única opción para evitar versiones feas y a menudo caras o incluso que no funcionan:

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

Sería bueno si la solución para este defecto de diseño se introdujera en la API de Java.

Si puede, cambie el ArrayListpor un ArrayDeque, que tiene métodos convenientes como removeLast.

Como se indica en la solución, si el Listestá vacío, IndexOutOfBoundsExceptionse arroja un. Una mejor solución es usar el 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));
    }
}

Como era de esperar, el último elemento de la lista se devuelve como Optional:

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

También trata con gracia las listas vacías:

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

Si utiliza una LinkedList en su lugar, puede acceder al primer elemento y al último con solo getFirst()y getLast()(si desea una forma más limpia que size () -1 y get (0))

Implementación

Declarar una lista enlazada

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

Entonces estos son los métodos que puede utilizar para obtener lo que desea, en este caso estamos hablando del elemento PRIMERO y ÚLTIMO de una lista

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

Entonces, puedes usar

mLinkedList.getLast(); 

para obtener el último elemento de la lista.

la guayaba proporciona otra forma de obtener el último elemento de a List:

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

si la lista proporcionada está vacía, arroja un IndexOutOfBoundsException

Dado que la indexación en ArrayList comienza desde 0 y termina un lugar antes del tamaño real, por lo tanto, la declaración correcta para devolver el último elemento de la lista sería:

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

Por ejemplo:

si el tamaño de la lista de la matriz es 5, entonces size-1 = 4 devolvería el último elemento de la matriz.

El último elemento de la lista es list.size() - 1. La colección está respaldada por una matriz y las matrices comienzan en el índice 0.

Entonces el elemento 1 en la lista está en el índice 0 en la matriz

El elemento 2 en la lista está en el índice 1 en la matriz

El elemento 3 en la lista está en el índice 2 en la matriz

y así..

Qué tal esto ... En algún lugar de tu clase ...

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

Si modifica su lista, use listIterator()e itere desde el último índice (es decir, size()-1respectivamente). Si vuelve a fallar, verifique la estructura de su lista.

Todo lo que necesita hacer es usar size () para obtener el último valor de la Arraylist. Por ej. si tiene ArrayList de enteros, para obtener el último valor tendrá que

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

Recuerde, se puede acceder a los elementos en una Arraylist usando valores de índice. Por lo tanto, las ArrayLists se usan generalmente para buscar elementos.

Las matrices almacenan su tamaño en una variable local llamada 'longitud'. Dada una matriz llamada "a", podría usar lo siguiente para hacer referencia al último índice sin conocer el valor del índice

a [a.length-1]

para asignar un valor de 5 a este último índice que usaría:

a [a.length-1] = 5;

Alternativa usando la API Stream:

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

Resultados en un Opcional del último elemento.

En Kotlin, puedes usar el método last:

val lastItem = list.last()