Obtenga el último elemento de una ArrayList en Java

  2. HowTo
  3. Howtos de Java
  4. Obtenga el último elemento de una …
Mohammad Irfan 12 octubre 2023
Java Java ArrayList
  1. Obtener el último elemento utilizando los métodos size() y get()
  2. Convertir ArrayList en LinkedList en Java
  3. Convertir ArrayList en ArrayDeque en Java
  4. Usando la biblioteca de guayaba
  5. Resumen
Obtenga el último elemento de una ArrayList en Java

Este tutorial presenta cómo obtener el último elemento de una ArrayList en Java y también enumera algunos códigos de ejemplo para comprender el tema.

Una ArrayList es un array dinámica que se puede utilizar para almacenar datos similares en una colección ordenada. Una gran cosa sobre Arrays y ArrayList es que permiten el acceso aleatorio a cualquier elemento almacenado en ellos, dado que conocemos el índice donde está almacenado. Pero, ¿cómo podemos acceder al último elemento de una ArrayList si no conocemos su índice? Algunos otros lenguajes como Python proporcionan indexación inversa, por lo que podemos usar -1 para acceder al último elemento. En este tutorial, aprenderemos cómo obtener el último elemento de una ArrayList en Java.

Obtener el último elemento utilizando los métodos size() y get()

Una ArrayList en Java tiene el método size() que se puede utilizar para encontrar el número de elementos presentes en 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());
  }
}

Producción :

The list contains 5 elements

Sabemos que el último índice de una ArrayList será uno menos que su longitud (porque sigue una indexación basada en cero). Podemos usar esta información para buscar el último elemento. Usaremos el método get() de ArrayList para obtener el último elemento.

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

Producción :

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

Escribamos un método genérico para evitar escribir la misma lógica una y otra vez.

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

Producción :

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

¿Qué pasará si ejecutamos nuestro método en una ArrayList vacía? Obtendremos una IndexOutOfBoundsException si ejecutamos el código anterior en una lista vacía. Esto sucede porque el método size() devuelve cero para una ArrayList vacía y cuando le restamos 1 obtenemos -1 como índice. No existe el índice negativo. El siguiente ejemplo devolverá esta excepción.

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

Revisemos algunas condiciones antes de ejecutar el método size(). Usaremos el método isEmpty() para comprobar si la lista está vacía.

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

Producción :

The last element of list is: null

Convertir ArrayList en LinkedList en Java

La clase LinkedList, al igual que ArrayList, implementa la interfaz List. La clase LinkedList tiene un método simple getLast() que puede usarse para buscar el último elemento de la lista.

Si podemos convertir nuestra ArrayList en una LinkedList, entonces podemos usar este método. Este proceso no modificará nuestra ArrayList original.

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

Producción :

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

La solución anterior no es una forma elegante de obtener el último elemento y no se recomienda. Si necesitamos acceder al último elemento varias veces, se recomienda usar LinkedList (o alguna otra colección) en lugar de ArrayList.

Convertir ArrayList en ArrayDeque en Java

Una deque es una cola de dos extremos. Un ArrayDeque combina las funcionalidades de array de tamaño variable con la estructura de datos deque. Al igual que LinkedList, ArrayDeque también tiene un método getLast() conveniente que se puede usar para ver el último elemento de la deque. Simplemente necesitamos convertir nuestro ArrayList en un ArrayDeque para hacer uso de este método.

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

Nuevamente, este método no es muy elegante y si necesitamos acceder al último elemento varias veces, se sugiere usar ArrayDeque en lugar de ArrayList.

Usando la biblioteca de guayaba

La biblioteca de Google Guava proporciona un método sencillo para obtener el último elemento de una ArrayList. Usaremos el método getLast() de la clase Iterables de esta biblioteca para obtener el último elemento. Asegúrese de descargar y agregar esta biblioteca a su proyecto antes de ejecutar el siguiente código.

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

Producción :

The last element of the array list is: 25

También podemos proporcionar un valor predeterminado al método getLast() para mostrar si la lista está vacía. Esto evitará que Java genere excepciones.

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

Producción :

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

Resumen

Una ArrayList es una estructura de datos muy común que se utiliza principalmente para eliminar el problema de los arrays normales de tamaño limitado. Es posible que no conozcamos el último índice de la lista en muchos casos, por lo que no podemos encontrar el último elemento almacenado en él.

Podemos usar los métodos size() y get() para ver este elemento. La biblioteca de Google Guava también proporciona una forma sencilla de obtener el último elemento.

Si con frecuencia necesitamos acceder al último elemento, es preferible utilizar alguna otra colección como LinkedList o ArrayDeque ya que estas colecciones tienen los métodos necesarios.

Artículo relacionado - Java ArrayList