Obtenha o último elemento de um ArrayList em Java

  2. HowTo
  3. Java Howtos
  4. Obtenha o último elemento de um …
Mohammad Irfan 12 outubro 2023
Java Java ArrayList
  1. Obtenha o último elemento usando os métodos size() e get()
  2. Converta ArrayList em LinkedList em Java
  3. Converta ArrayList em ArrayDeque em Java
  4. Usando a Biblioteca Guava
  5. Resumo
Obtenha o último elemento de um ArrayList em Java

Este tutorial apresenta como obter o último elemento de um ArrayList em Java e também lista alguns códigos de exemplo para entender o tópico.

Uma ArrayList é um array dinâmica que pode ser usada para armazenar dados semelhantes em uma coleção ordenada. Uma grande coisa sobre Arrays e ArrayList é que eles permitem acesso aleatório a qualquer elemento armazenado neles, desde que conheçamos o índice onde ele está armazenado. Mas como podemos acessar o último elemento de um ArrayList se não sabemos seu índice? Algumas outras linguagens como Python fornecem indexação reversa para que possamos usar -1 para acessar o último elemento. Neste tutorial, aprenderemos como obter o último elemento de um ArrayList em Java.

Obtenha o último elemento usando os métodos size() e get()

Uma ArrayList em Java tem o método size() que pode ser usado para encontrar o número de elementos presentes na 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());
  }
}

Produção:

The list contains 5 elements

Sabemos que o último índice de uma ArrayList será um a menos que seu comprimento (porque segue a indexação baseada em zero). Podemos usar essas informações para buscar o último elemento. Usaremos o método get() de ArrayList para obter o ú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);
  }
}

Produção:

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

Vamos escrever um método genérico para evitar escrever a mesma lógica repetidamente.

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

Produção:

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

O que acontecerá se executarmos nosso método em uma ArrayList vazia? Obteremos uma IndexOutOfBoundsException se executarmos o código acima em uma lista vazia. Isso acontece porque o método size() retorna zero para um ArrayList vazio e quando subtraímos 1 dele obtemos -1 como o índice. Não existe índice negativo. O exemplo a seguir retornará essa exceção.

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

Vamos verificar algumas condições antes de executar o método size(). Usaremos o método isEmpty() para verificar se a lista está vazia.

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

Produção:

The last element of list is: null

Converta ArrayList em LinkedList em Java

A classe LinkedList, assim como ArrayList, implementa a interface List. A classe LinkedList tem um método getLast() simples que pode ser usado para buscar o último elemento da lista.

Se pudermos converter nossa ArrayList em uma LinkedList, então podemos usar este método. Este processo não modificará nossa 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);
  }
}

Produção:

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

A solução acima não é uma maneira elegante de obter o último elemento e não é recomendada. Se precisarmos acessar o último elemento várias vezes, é recomendável usar LinkedList (ou alguma outra coleção) em vez de ArrayList.

Converta ArrayList em ArrayDeque em Java

Um deque é uma fila dupla. Um ArrayDeque combina as funcionalidades de array redimensionável com a estrutura de dados deque. Assim como LinkedList, o ArrayDeque também tem um método getLast() conveniente que pode ser usado para visualizar o último elemento do deque. Precisamos simplesmente converter nosso ArrayList em um ArrayDeque para usar esse 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);
  }
}

Novamente, esse método não é muito elegante e se precisarmos acessar o último elemento várias vezes, sugerimos usar ArrayDeque em vez de um ArrayList.

Usando a Biblioteca Guava

A biblioteca Google Guava fornece um método fácil de obter o último elemento de um ArrayList. Usaremos o método getLast() da classe Iterables desta biblioteca para obter o último elemento. Certifique-se de baixar e adicionar esta biblioteca ao seu projeto antes de executar o código a seguir.

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

Produção:

The last element of the array list is: 25

Também podemos fornecer um valor padrão para o método getLast() para exibir se a lista estiver vazia. Isso impedirá o Java de lançar quaisquer exceções.

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

Produção:

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

Resumo

Uma ArrayList é uma estrutura de dados muito comum usada principalmente para eliminar o problema de arrayes normais em tamanho limitado. Podemos não saber o último índice da lista em muitos casos, então não podemos encontrar o último elemento armazenado nela.

Podemos usar os métodos size() e get() para visualizar este elemento. A biblioteca Google Guava também oferece uma maneira fácil de buscar o último elemento.

Se frequentemente precisamos acessar o último elemento, é preferível usar alguma outra coleção como LinkedList ou ArrayDeque, pois essas coleções têm os métodos necessários.

Artigo relacionado - Java ArrayList