Obtenir le dernier élément d'un ArrayList en Java

  2. HowTo
  3. Howtos de Java
  4. Obtenir le dernier élément d'un …
Mohammad Irfan 12 octobre 2023
Java Java ArrayList
  1. Obtenir le dernier élément en utilisant les méthodes size() et get()
  2. Convertir ArrayList en LinkedList en Java
  3. Convertir ArrayList en ArrayDeque en Java
  4. Utiliser la bibliothèque de goyave
  5. Sommaire
Obtenir le dernier élément d'un ArrayList en Java

Ce tutoriel présente comment obtenir le dernier élément d’une ArrayList en Java, et répertorie également quelques exemples de codes pour comprendre le sujet.

Une ArrayList est un tableau dynamique qui peut être utilisé pour stocker des données similaires dans une collection ordonnée. Un grand avantage des Arrays et des ArrayList est qu’ils permettent un accès aléatoire à tout élément qui y est stocké, étant donné que nous connaissons l’index où il est stocké. Mais comment pouvons-nous accéder au dernier élément d’un ArrayList si nous ne connaissons pas son index ? Certains autres langages comme Python fournissent une indexation inversée afin que nous puissions utiliser -1 pour accéder au dernier élément. Dans ce tutoriel, nous allons apprendre à récupérer le dernier élément d’un ArrayList en Java.

Obtenir le dernier élément en utilisant les méthodes size() et get()

Une ArrayList en Java possède la méthode size() qui permet de trouver le nombre d’éléments présents dans la ArrayList.

import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    System.out.printf("The list contains %d elements", list.size());
  }
}

Production:

The list contains 5 elements

Nous savons que le dernier index d’un ArrayList sera un de moins que sa longueur (car il suit une indexation de base zéro). Nous pouvons utiliser ces informations pour récupérer le dernier élément. Nous utiliserons la méthode get() de ArrayList pour récupérer le dernier élément.

import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    int lastIdx = list.size() - 1;
    int lastElement = list.get(lastIdx);
    System.out.println("The last index of list is: " + lastIdx);
    System.out.print("The last element of list is: " + lastElement);
  }
}

Production:

The last index of list is: 4The last element of list is: 25

Écrivons une méthode générique pour éviter d’écrire encore et encore la même logique.

import java.util.ArrayList;
public class LastElement {
  public static <E> E getLastElement(ArrayList<E> list) {
    int lastIdx = list.size() - 1;
    E lastElement = list.get(lastIdx);
    return lastElement;
  }
  public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    list1.add(5);
    list1.add(10);
    list1.add(15);
    list1.add(20);
    list1.add(25);
    ArrayList<String> list2 = new ArrayList<String>();
    list2.add("1");
    list2.add("2");
    list2.add("3");
    System.out.println("The last element of list1 is: " + getLastElement(list1));
    System.out.print("The last element of list2 is: " + getLastElement(list2));
  }
}

Production:

The last element of list1 is : 25 The last element of list2 is : 3

Que se passera-t-il si nous exécutons notre méthode sur une ArrayList vide ? Nous obtiendrons une IndexOutOfBoundsException si nous exécutons le code ci-dessus sur une liste vide. Cela se produit parce que la méthode size() renvoie zéro pour une ArrayList vide et lorsque nous en soustrayons 1 nous obtenons -1 comme index. Il n’existe pas d’indice négatif. L’exemple suivant renverra cette exception.

import java.util.ArrayList;
public class LastElement {
  public static <E> E getLastElement(ArrayList<E> list) {
    int lastIdx = list.size() - 1;
    E lastElement = list.get(lastIdx);
    return lastElement;
  }
  public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    System.out.println("The last element of list1 is: " + getLastElement(list1));
  }
}

Vérifions quelques conditions avant d’exécuter la méthode size(). Nous utiliserons la méthode isEmpty() pour vérifier si la liste est vide.

import java.util.ArrayList;
public class LastElement {
  public static <E> E getLastElement(ArrayList<E> list) {
    if ((list != null) && (list.isEmpty() == false)) {
      int lastIdx = list.size() - 1;
      E lastElement = list.get(lastIdx);
      return lastElement;
    } else
      return null;
  }
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    System.out.println("The last element of list is: " + getLastElement(list));
  }
}

Production:

The last element of list is: null

Convertir ArrayList en LinkedList en Java

La classe LinkedList, tout comme ArrayList, implémente l’interface List. La classe LinkedList a une méthode simple getLast() qui peut être utilisée pour récupérer le dernier élément de la liste.

Si nous pouvons convertir notre ArrayList en une LinkedList, alors nous pouvons utiliser cette méthode. Ce processus ne modifiera pas notre ArrayList d’origine.

import java.util.ArrayList;
import java.util.LinkedList public class LastElement {
  public static <E> E getLastElementUsingLinkedList(ArrayList<E> arrList) {
    LinkedList<E> linkedList = new LinkedList<E>(arrList);
    return linkedList.getLast();
  }
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    System.out.println("The last element of list is: " + getLastElementUsingLinkedList(list));
    System.out.print("The array list is: " + list);
  }
}

Production:

The last element of list is: 25
The array list is: [5, 10, 15, 20, 25]

La solution ci-dessus n’est pas une manière élégante d’obtenir le dernier élément et elle n’est pas recommandée. Si nous devons accéder plusieurs fois au dernier élément, il est recommandé d’utiliser LinkedList (ou une autre collection) au lieu de ArrayList.

Convertir ArrayList en ArrayDeque en Java

Un deque est une file d’attente à deux extrémités. Un ArrayDeque combine les fonctionnalités de tableau redimensionnables avec la structure de données deque. Tout comme LinkedList, ArrayDeque possède également une méthode getLast() pratique qui peut être utilisée pour afficher le dernier élément du deque. Nous devons simplement convertir notre ArrayList en ArrayDeque pour utiliser cette méthode.

import java.util.ArrayDeque;
import java.util.ArrayList;
public class LastElement {
  public static <E> Object getLastElementUsingArrayDeque(ArrayList<E> arrList) {
    ArrayDeque<E> deque = new ArrayDeque<E>(arrList);
    return deque.getLast();
  }
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    System.out.println("The last element of list is: " + getLastElementUsingArrayDeque(list));
    System.out.print("The array list is: " + list);
  }
}

Encore une fois, cette méthode n’est pas très élégante et si nous devons accéder plusieurs fois au dernier élément, il est suggéré d’utiliser ArrayDeque au lieu d’un ArrayList.

Utiliser la bibliothèque de goyave

La bibliothèque Google Guava fournit une méthode simple pour obtenir le dernier élément d’un ArrayList. Nous utiliserons la méthode getLast() de la classe Iterables de cette bibliothèque pour récupérer le dernier élément. Assurez-vous de télécharger et d’ajouter cette bibliothèque à votre projet avant d’exécuter le code suivant.

import com.google.common.collect.Iterables;
import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(10);
    list.add(15);
    list.add(20);
    list.add(25);
    Integer lastEle = Iterables.getLast(list);
    System.out.print("The last element of the array list is: " + lastEle);
  }
}

Production:

The last element of the array list is: 25

Nous pouvons également fournir une valeur par défaut à la méthode getLast() à afficher si la liste est vide. Cela empêchera Java de lever des exceptions.

import com.google.common.collect.Iterables;
import java.util.ArrayList;
public class LastElement {
  public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<String>();
    String lastEle = Iterables.getLast(list, "No Element Found"); // No Element Found is the
                                                                  // default value
    System.out.print("The last element of the array list is: " + lastEle);
  }
}

Production:

The last element of the array list is: No Element Found

Sommaire

Une ArrayList est une structure de données très courante qui est principalement utilisée pour éliminer le problème des tableaux normaux sur une taille limitée. Nous pouvons ne pas connaître le dernier index de la liste dans de nombreux cas, nous ne pouvons donc pas trouver le dernier élément qui y est stocké.

Nous pouvons utiliser les méthodes size() et get() pour visualiser cet élément. La bibliothèque Google Guava fournit également un moyen simple de récupérer le dernier élément.

Si nous avons fréquemment besoin d’accéder au dernier élément, il est préférable d’utiliser une autre collection comme LinkedList ou ArrayDeque car ces collections ont les méthodes requises.

Article connexe - Java ArrayList