Comment obtenir la dernière valeur d'un ArrayList
Comment puis-je obtenir la dernière valeur d'un ArrayList?
Je ne connais pas le dernier index de ArrayList.
Ce qui suit fait partie de l'interface List (implémentée par ArrayList):
E e = list.get(list.size() - 1);
E est le type d'élément. Si la liste est vide, get jette un IndexOutOfBoundsException . Vous pouvez trouver toute la documentation de l'API ici .
cela devrait le faire:
if (arrayList != null && !arrayList.isEmpty()) {
T item = arrayList.get(arrayList.size()-1);
}
Il n'y a pas de manière élégante dans Vanilla Java.
Google Guava
La bibliothèque Google Guava est géniale. Découvrez leur classe Iterables . Cette méthode jette un NoSuchElementException si la liste est vide, par opposition à un IndexOutOfBoundsException , comme avec l'approche size()-1 typique - je trouve un NoSuchElementException beaucoup plus agréable, ou la possibilité de spécifier un paramètre par défaut:
lastElement = Iterables.getLast(iterableList);
Vous pouvez également fournir une valeur par défaut si la liste est vide, à la place d'une exception:
lastElement = Iterables.getLast(iterableList, null);
ou, si vous utilisez Options:
lastElementRaw = Iterables.getLast(iterableList, null);
lastElement = (lastElementRaw == null) ? Option.none() : Option.some(lastElementRaw);
J'utilise la classe micro-util pour obtenir le dernier (et le premier) élément de la liste:
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;
}
}
Légèrement plus 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();
}
}
La méthode size() renvoie le nombre d'éléments dans ArrayList. Les valeurs d'index des éléments sont 0 à (size()-1), vous utiliserez donc myArrayList.get(myArrayList.size()-1) pour récupérer le dernier élément.
Utilisation de lambdas:
Function<ArrayList<T>, T> getLast = a -> a.get(a.size() - 1);
Si vous le pouvez, remplacez la ArrayList par une ArrayDeque, qui comporte des méthodes pratiques comme removeLast.
Let ArrayList is myList
public void getLastValue(List myList){
// Check ArrayList is null or Empty
if(myList == null || myList.isEmpty()){
return;
}
// check size of arrayList
int size = myList.size();
// Since get method of Arraylist throws IndexOutOfBoundsException if index >= size of arrayList. And in arraylist item inserts from 0th index.
//So please take care that last index will be (size of arrayList - 1)
System.out.print("last value := "+myList.get(size-1));
}
Comme indiqué dans la solution, si la variable List est vide, une variable IndexOutOfBoundsException est émise. Une meilleure solution consiste à utiliser le type 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));
}
}
Comme vous vous en doutez, le dernier élément de la liste est renvoyé sous la forme Optional:
var list = List.of(10, 20, 30);
assert ListUtils.last(list).orElse(-1) == 30;
Il gère également les listes vides:
var emptyList = List.<Integer>of();
assert ListUtils.last(emptyList).orElse(-1) == -1;
Si vous utilisez plutôt une LinkedList, vous pouvez accéder au premier et au dernier élément avec seulement getFirst() et getLast() (si vous voulez un moyen plus propre que size () -1 et get (0))
La mise en oeuvre
Déclarer une liste liée
LinkedList<Object> mLinkedList = new LinkedList<>();
Ensuite, ce sont les méthodes que vous pouvez utiliser pour obtenir ce que vous voulez, dans ce cas nous parlons deFIRSTetLASTélément d'une liste
/**
* 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);
}
Alors, alors vous pouvez utiliser
mLinkedList.getLast();
pour obtenir le dernier élément de la liste.
Alternative utilisant l'API Stream:
list.stream().reduce((first, second) -> second)
Résultats dans une option du dernier élément.
Le dernier élément de la liste est list.size() - 1. La collection est sauvegardée par un tableau et les tableaux commencent à l'indice 0.
Donc, l'élément 1 de la liste est à l'index 0 du tableau
L'élément 2 de la liste est à l'index 1 du tableau
L'élément 3 de la liste est à l'index 2 du tableau
etc..
Il n’existe pas de méthode élégante pour obtenir le dernier élément d’une liste en Java (par exemple, items[-1] en Python).
Vous devez utiliser list.get(list.size()-1).
Lorsque vous travaillez avec des listes obtenues par des appels de méthode compliqués, la solution de contournement consiste en une variable temporaire:
List<E> list = someObject.someMethod(someArgument, anotherObject.anotherMethod());
return list.get(list.size()-1);
C'est la seule option pour éviter une version laide et souvent chère ou même ne fonctionnant pas:
return someObject.someMethod(someArgument, anotherObject.anotherMethod()).get(
someObject.someMethod(someArgument, anotherObject.anotherMethod()).size() - 1
);
Ce serait bien si le correctif de cette faille de conception était introduit dans les API Java.