这应该这样做：

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

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

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

E是元素类型。如果列表为空，get抛出IndexOutOfBoundsException。您可以找到整个API留档这里。

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

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

香草Java没有优雅的方式。

googleguava

googleguava库很棒-查看他们的Iterables类。如果列表为空，此方法将抛出NoSuchElementException，而不是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);

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

如果可以，请将ArrayList换成ArrayDeque，它具有像removeLast这样的方便方法。

这个怎么样？ 在你的课堂上…

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

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

所以列表中的元素1在数组的索引0处

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

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

等等…

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

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

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

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

[a.length-1]

要将值5分配给最后一个索引，您将使用：

a[a.length-1]=5；

使用lambdas：

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

如果你使用LinkedList，你可以只使用getFirst()和getLast()访问第一个元素和最后一个元素（如果你想要一个比size（）-1更干净的方法并获得（0））

实施

声明一个LinkedList

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

然后这是你可以用来得到你想要的东西的方法，在这种情况下，我们谈论的是列表的第一和最后元素

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

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

使用Stream API的替代方案：

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

结果为最后一个元素的可选值。

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

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

您必须使用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
);

如果将此设计缺陷的修复引入到JavaAPI中，那就太好了。

在静态编程语言中，您可以使用方法last：

val lastItem = list.last()

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

int Last=mylist.get（mylist.size（）-1）；

例如：

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

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

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

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

如果你有Spring项目，你也可以使用Spring的CollectionUtils.lastElement（javadoc），所以你不需要像Google Guava那样添加额外的依赖项。

它是null安全的，因此如果您传递null，您将简单地接收null作为返回。不过，在处理响应时要小心。

以下是一些单元测试来演示它们：

@Test
void lastElementOfList() {
var names = List.of("John", "Jane");


var lastName = CollectionUtils.lastElement(names);


then(lastName)
.as("Expected Jane to be the last name in the list")
.isEqualTo("Jane");
}


@Test
void lastElementOfSet() {
var names = new TreeSet<>(Set.of("Jane", "John", "James"));


var lastName = CollectionUtils.lastElement(names);


then(lastName)
.as("Expected John to be the last name in the list")
.isEqualTo("John");
}

注意：org.assertj.core.api.BDDAssertions#then(java.lang.String)用于断言。

这对我有用。

private ArrayList<String> meals;
public String take(){
return meals.remove(meals.size()-1);
}

考虑到空列表的一行将是：

T lastItem = list.size() == 0 ? null : list.get(list.size() - 1);

或者，如果您不喜欢空值（并且性能不是问题）：

Optional<T> lastItem = list.stream().reduce((first, second) -> second);

在JavaScript中获取arraylist的最后一个值：

var yourlist = ["1","2","3"];
var lastvalue = yourlist[yourlist.length -1];

它给出的输出为3。