Comment obtenir la dernière valeur d'une ArrayList?

Je ne connais pas le dernier index de la ArrayList.

Ce qui suit fait partie de l' Listinterface (qu'ArrayList implémente):

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

Eest le type d'élément. Si la liste est vide, getlance un IndexOutOfBoundsException. Vous pouvez trouver toute la documentation de l'API ici .

Il n'y a pas de méthode élégante en Java vanille.

Google Guava

La bibliothèque Google Guava est géniale - consultez leur Iterablesclasse . Cette méthode lancera un NoSuchElementExceptionsi la liste est vide, par opposition à un IndexOutOfBoundsException, comme avec l' size()-1approche typique - je trouve NoSuchElementExceptionbeaucoup plus agréable, ou la possibilité de spécifier un défaut:

lastElement = Iterables.getLast(iterableList);

Vous pouvez également fournir une valeur par défaut si la liste est vide, au lieu d'une exception:

lastElement = Iterables.getLast(iterableList, null);

ou, si vous utilisez les options:

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

cela devrait le faire:

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

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

Un peu 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 size()méthode renvoie le nombre d'éléments dans ArrayList. Les valeurs d'index des éléments sont 0terminées (size()-1), vous pouvez donc utiliser 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);

Il n'y a aucun moyen élégant d'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 réside dans la 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 moche et souvent chère voire ne fonctionnant pas:

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

Ce serait bien si un correctif pour cette faille de conception était introduit dans l'API Java.

Si vous le pouvez, remplacez le ArrayListpar un ArrayDeque, qui a des méthodes pratiques comme removeLast.

Comme indiqué dans la solution, si le Listest vide, un IndexOutOfBoundsExceptionest lancé. Une meilleure solution consiste à utiliser le Optionaltype:

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 traite également gracieusement les listes vides:

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

Si vous utilisez une LinkedList à la place, vous pouvez accéder au premier élément et au dernier avec juste getFirst()et getLast()(si vous voulez un moyen plus propre que size () -1 et obtenez (0))

la mise en oeuvre

Déclarez une LinkedList

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 de FIRST et LAST é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);
    }

Vous pouvez donc utiliser

mLinkedList.getLast(); 

pour obtenir le dernier élément de la liste.

la goyave fournit un autre moyen d'obtenir le dernier élément d'un List:

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

si la liste fournie est vide, elle lance un IndexOutOfBoundsException

Étant donné que l'indexation dans ArrayList commence à 0 et se termine à une place avant la taille réelle, la déclaration correcte pour renvoyer le dernier élément arraylist serait:

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

Par exemple:

si la taille de la liste de tableaux est 5, alors size-1 = 4 retournerait le dernier élément du tableau.

Le dernier élément de la liste est list.size() - 1. La collection est soutenue par un tableau et les tableaux commencent à l'index 0.

L'élément 1 de la liste est donc à 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..

Que diriez-vous de cela ... Quelque part dans votre classe ...

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 vous modifiez votre liste, utilisez listIterator()et répétez le dernier index (c'est-à-dire size()-1respectivement). Si vous échouez à nouveau, vérifiez la structure de votre liste.

Tout ce que vous devez faire est d'utiliser size () pour obtenir la dernière valeur de l'arraylist. Par exemple. si vous ArrayList d'entiers, alors pour obtenir la dernière valeur, vous devrez

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

N'oubliez pas que les éléments d'une liste Arraylist sont accessibles à l'aide de valeurs d'index. Par conséquent, les listes de tableaux sont généralement utilisées pour rechercher des éléments.

les tableaux stockent leur taille dans une variable locale appelée «longueur». Étant donné un tableau nommé "a", vous pouvez utiliser ce qui suit pour référencer le dernier index sans connaître la valeur d'index

a [a.length-1]

pour attribuer une valeur de 5 à ce dernier index, vous utiliseriez:

a [a.length-1] = 5;

Alternative utilisant l'API Stream:

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

Entraîne une option du dernier élément.

Dans Kotlin, vous pouvez utiliser la méthode last:

val lastItem = list.last()