如何获取ArrayList的最后一个值？

我不知道ArrayList的最后一个索引。

以下是List接口的一部分（由ArrayList实现）：

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

E是元素类型。如果列表为空，则get抛出IndexOutOfBoundsException。您可以在此处找到整个API文档。

原始Java中没有一种优雅的方法。

谷歌番石榴

在谷歌番石榴库是伟大的-看看他们的Iterables阶级。NoSuchElementException如果列表为空，则此方法将抛出a ，而不是使用IndexOutOfBoundsException，与典型size()-1方法一样-我发现NoSuchElementException更好，或者可以指定默认值：

lastElement = Iterables.getLast(iterableList);

如果列表为空，还可以提供一个默认值，而不是一个异常：

lastElement = Iterables.getLast(iterableList, null);

或者，如果您使用的是选项：

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

这应该做到这一点：

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

我使用micro-util类获取列表的最后一个（和第一个）元素：

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

稍微灵活一些：

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

该size()方法返回ArrayList中的元素数。元素的索引值0通过(size()-1)，因此您将myArrayList.get(myArrayList.size()-1)用来检索最后一个元素。

使用lambda：

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

如果可以的话，换出ArrayList一个ArrayDeque，它具有方便的方法类似removeLast。

没有一种优雅的方法来获取Java中列表的最后一个元素（与items[-1]Python中相比）。

您必须使用list.get(list.size()-1)。

当处理通过复杂方法调用获得的列表时，解决方法在于临时变量：

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

这是避免使用丑陋且通常昂贵甚至不工作的版本的唯一选择：

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

如果针对Java API引入了针对此设计缺陷的修复程序，那就太好了。

如解决方案中所述，如果Listan IndexOutOfBoundsException为空，则抛出an 。更好的解决方案是使用以下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));
    }
}

如您所料，列表的最后一个元素以形式返回Optional：

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

它还可以很好地处理空列表：

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

如果改用LinkedList，则可以使用just getFirst()和访问第一个元素和最后一个元素getLast()（如果您希望使用比size（）-1和get（0）更为简洁的方法）

实作

声明一个LinkedList

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

这就是您可以用来获取所需内容的方法，在这种情况下，我们正在谈论列表的FIRST和LAST元素

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

所以，那么您可以使用

mLinkedList.getLast(); 

获取列表的最后一个元素。

番石榴提供了另一种从中获取最后一个元素的方法List：

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

如果提供的列表为空，则抛出 IndexOutOfBoundsException

由于ArrayList中的索引从0开始并在实际大小之前结束一位，因此返回最后一个arraylist元素的正确语句将是：

int last = mylist.get（mylist.size（）-1）;

例如：

如果数组列表的大小为5，则size-1 = 4将返回最后一个数组元素。

列表中的最后一项是list.size() - 1。集合由数组支持，数组从索引0开始。

因此列表中的元素1在数组的索引0处

列表中的元素2在数组的索引1处

列表中的元素3在数组的索引2处

等等..

怎么样。.在你课堂的某个地方...

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

如果您修改列表，请使用listIterator()并从最后一个索引开始迭代（size()-1分别）。如果再次失败，请检查列表结构。

您需要做的就是使用size（）获得Arraylist的最后一个值。对于前。如果您是整数的ArrayList，那么要获取最后一个值，您将必须

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

请记住，可以使用索引值访问Arraylist中的元素。因此，ArrayList通常用于搜索项目。

数组将其大小存储在称为“长度”的局部变量中。给定名为“ a”的数组，您可以使用以下内容引用最后一个索引，而无需知道索引值

a [a.length-1]

为最后一个索引分配值5，您可以使用：

a [a.length-1] = 5;

使用Stream API的替代方法：

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

结果是最后一个元素的Optional。

在Kotlin中，您可以使用方法last：

val lastItem = list.last()