Obtenha o último elemento de um ArrayList em Java
-
Obtenha o último elemento usando os métodos
size()eget() -
Converta
ArrayListemLinkedListem Java -
Converta
ArrayListemArrayDequeem Java - Usando a Biblioteca Guava
- Resumo
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.