How can I get the last value of an ArrayList?
getLast()
The following is part of the List
interface (which ArrayList implements):
E e = list.get(list.size() - 1);
E
is the element type. If the list is empty, get
throws an IndexOutOfBoundsException
. You can find the whole API documentation here.
There isn't an elegant way in vanilla Java.
Google Guava
The Google Guava library is great - check out their Iterables
class. This method will throw a NoSuchElementException
if the list is empty, as opposed to an IndexOutOfBoundsException
, as with the typical size()-1
approach - I find a NoSuchElementException
much nicer, or the ability to specify a default:
lastElement = Iterables.getLast(iterableList);
You can also provide a default value if the list is empty, instead of an exception:
lastElement = Iterables.getLast(iterableList, null);
or, if you're using Options:
lastElementRaw = Iterables.getLast(iterableList, null);
lastElement = (lastElementRaw == null) ? Option.none() : Option.some(lastElementRaw);
Iterables.getLast
check whether RandomAccess
is implemented and therefore if it is accesses the item in O(1).
Option
, you can use the native Java Optional
. It will also be a bit cleaner: lastElement = Optional.ofNullable(lastElementRaw);
.
this should do it:
if (arrayList != null && !arrayList.isEmpty()) {
T item = arrayList.get(arrayList.size()-1);
}
I use micro-util class for getting last (and first) element of list:
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;
}
}
Slightly more 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();
}
}
isEmpty
doesn't check whether the list is empty and should thus be isNullOrEmpty
and that's not part of the question - either you try to enhance the set of answers or you provide you utility classes (which are a re-invention).
The size()
method returns the number of elements in the ArrayList. The index values of the elements are 0
through (size()-1)
, so you would use myArrayList.get(myArrayList.size()-1)
to retrieve the last element.
There is no elegant way of getting the last element of a list in Java (compared to e.g. items[-1]
in Python).
You have to use list.get(list.size()-1)
.
When working with lists obtained by complicated method calls, the workaround lies in temporary variable:
List<E> list = someObject.someMethod(someArgument, anotherObject.anotherMethod());
return list.get(list.size()-1);
This is the only option to avoid ugly and often expensive or even not working version:
return someObject.someMethod(someArgument, anotherObject.anotherMethod()).get(
someObject.someMethod(someArgument, anotherObject.anotherMethod()).size() - 1
);
It would be nice if fix for this design flaw was introduced to Java API.
List
interface. Why would you want to call a method returning a List, if you're only interested in the last element? I do not remember I have seen that at all before.
list.get(list.size()-1)
is the minimal example showing the issue. I agree that the "advanced" examples may be controversial and possibly an edge case, I just wanted to show how the issue can further propagate. Let's assume that the class of someObject
is foreign, coming from external library.
ArrayDeque
instead.
ArrayList
.
Using lambdas:
Function<ArrayList<T>, T> getLast = a -> a.get(a.size() - 1);
If you can, swap out the ArrayList
for an ArrayDeque
, which has convenient methods like removeLast
.
As stated in the solution, if the List
is empty then an IndexOutOfBoundsException
is thrown. A better solution is to use the Optional
type:
public class ListUtils {
public static <T> Optional<T> last(List<T> list) {
return list.isEmpty() ? Optional.empty() : Optional.of(list.get(list.size() - 1));
}
}
As you'd expect, the last element of the list is returned as an Optional
:
var list = List.of(10, 20, 30);
assert ListUtils.last(list).orElse(-1) == 30;
It also deals gracefully with empty lists as well:
var emptyList = List.<Integer>of();
assert ListUtils.last(emptyList).orElse(-1) == -1;
If you use a LinkedList instead , you can access the first element and the last one with just getFirst()
and getLast()
(if you want a cleaner way than size() -1 and get(0))
Implementation
Declare a LinkedList
LinkedList<Object> mLinkedList = new LinkedList<>();
Then this are the methods you can use to get what you want, in this case we are talking about FIRST and LAST element of a list
/**
* 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 , then you can use
mLinkedList.getLast();
to get the last element of the list.
A one liner that takes into account empty lists would be:
T lastItem = list.size() == 0 ? null : list.get(list.size() - 1);
Or if you don't like null values (and performance isn't an issue):
Optional<T> lastItem = list.stream().reduce((first, second) -> second);
In case you have a Spring project, you can also use the CollectionUtils.lastElement
from Spring (javadoc), so you don't need to add an extra dependency like Google Guava.
It is null-safe so if you pass null, you will simply receive null in return. Be careful when handling the response though.
Here are somes unit test to demonstrate them:
@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");
}
Note: org.assertj.core.api.BDDAssertions#then(java.lang.String)
is used for assertions.
Since the indexing in ArrayList starts from 0 and ends one place before the actual size hence the correct statement to return the last arraylist element would be:
int last = mylist.get(mylist.size()-1);
For example:
if size of array list is 5, then size-1 = 4 would return the last array element.
guava provides another way to obtain the last element from a List
:
last = Lists.reverse(list).get(0)
if the provided list is empty it throws an IndexOutOfBoundsException
java.util.Collections#reverse
does it, too.
This worked for me.
private ArrayList<String> meals;
public String take(){
return meals.remove(meals.size()-1);
}
The last item in the list is list.size() - 1
. The collection is backed by an array and arrays start at index 0.
So element 1 in the list is at index 0 in the array
Element 2 in the list is at index 1 in the array
Element 3 in the list is at index 2 in the array
and so on..
How about this.. Somewhere in your class...
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;
}
If you modify your list, then use listIterator()
and iterate from last index (that is size()-1
respectively). If you fail again, check your list structure.
All you need to do is use size() to get the last value of the Arraylist. For ex. if you ArrayList of integers, then to get last value you will have to
int lastValue = arrList.get(arrList.size()-1);
Remember, elements in an Arraylist can be accessed using index values. Therefore, ArrayLists are generally used to search items.
arrays store their size in a local variable called 'length'. Given an array named "a" you could use the following to reference the last index without knowing the index value
a[a.length-1]
to assign a value of 5 to this last index you would use:
a[a.length-1]=5;
ArrayList
not an array.
To Get the last value of arraylist in JavaScript :
var yourlist = ["1","2","3"];
var lastvalue = yourlist[yourlist.length -1];
It gives the output as 3 .
Alternative using the Stream API:
list.stream().reduce((first, second) -> second)
Results in an Optional of the last element.
In Kotlin, you can use the method last
:
val lastItem = list.last()
Success story sharing
lastElement()
method for theirVector
but not forArrayList
. What's up with that inconsistency?