Método Sublist() em Java: ArrayList e List

O que é o método subList()?

O Collections Framework é um componente muito popular na API Java. A interface List e a classe ArrayList são provavelmente as ferramentas mais importantes no Collections Framework. subList é um método na interface List que permite criar uma nova lista a partir de uma parte de uma lista existente. No entanto, esta lista recém-criada é apenas uma visualização com referência à lista original. Por exemplo, pegue a lista de [1,2,3,4,5,6]. Suponha que você queira criar uma nova lista sem o primeiro e o último elemento. Nesse cenário, o método list.subList() irá ajudá-lo. O método subList(fromIndex, toIndex) possui apenas um formulário e recebe dois argumentos, que são o primeiro índice (fromIndex) e o último índice(para Índice) . Ele retornará a parte entre fromIndex e toIndex como uma nova lista. Há um ponto importante a ser lembrado. A lista recém-criada incluirá o fromIndex e excluirá o toIndex. Portanto, o algoritmo para o cenário acima será mais ou menos assim. List = [1,2,3,4,5,6] newList = List.subList(1,5) Como subList é um método da interface List, você pode usá-lo em objetos ArrayList, LinkedList, Stack e Vector. No entanto, neste artigo, vamos nos concentrar principalmente nos objetos ArrayList e LinkedList.

Exemplo do método subList em um objeto ArrayList.

Estamos declarando um ArrayList de países. Em seguida, tentamos devolver a parte entre o 2º e o 4º elementos.

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
         // create an ArrayList 
        ArrayList list = new ArrayList();
         // add values to ArrayList
         list.add("USA");
         list.add("UK");
         list.add("France");
         list.add("Germany");
         list.add("Russia");
        System.out.println("List of the countries:" + list);
         //Return the subList : 1 inclusive and 3 exclusive
        ArrayList new_list = new  ArrayList(list.subList(1, 3));
        System.out.println("The subList of the list: "+new_list);
    }
 }

A saída do código acima será Em uma ArrayList, o valor de índice do primeiro elemento é 0. Portanto, os valores de índice do segundo e quarto elementos são 1 e 3, respectivamente. Assim, invocamos o método sublist() como list.subList(1, 3) . Porém, lembre-se que o método subList retorna a parte excluindo o toIndex que é o quarto elemento (“Alemanha”) neste caso. Assim, produzirá apenas “Reino Unido” e “França” . Como a saída retornada é uma List em si, você pode chamar qualquer método List diretamente nela. Então, o que acontecerá se usarmos o mesmo índice para ambos os parâmetros? Esse índice será incluído ou excluído na lista retornada? Vamos descobrir.

//execute subList() method with the same argument for both parameters.
ArrayList new_list2 = new ArrayList(list.subList(3, 3));
System.out.println("The subList of the list: "+new_list2);

A saída é A saída é uma lista vazia. Embora fromIndex selecione o 4º elemento, o método subList() irá removê-lo, pois também é o toIndex.

Exemplo do método subList em um objeto LinkedList.

Neste exemplo, usaremos o método sublist em um elemento LinkedList. Novamente, ele retornará a lista entre o índice especificado fromIndex(inclusive) e toIndex(exclusive) . Lembre-se que dissemos que a lista retornada pelo método subList() é apenas uma view que possui uma referência à lista original. Se você fizer alguma alteração na sublista, isso também afetará a lista original. Vamos testar isso também neste exemplo.

import java.util.LinkedList;
import java.util.Iterator;
import java.util.List;
 
public class Main {
 
 public static void main(String[] args) {
 
    // Create a LinkedList
    LinkedList linkedlist = new LinkedList();
 
    // Add elements to LinkedList
    for(int i = 0; i<7; i++){
      linkedlist.add("Node "+ (i+1));
    }
 
    // Displaying LinkedList elements
    System.out.println("Elements of the LinkedList:");
    Iterator it= linkedlist.iterator();
    while(it.hasNext()){
       System.out.print(it.next()+ " ");
    }
 
    // invoke subList() method on the linkedList
    List sublist = linkedlist.subList(2,5);
 
    // Displaying SubList elements
    System.out.println("\nElements of the sublist:");
    Iterator subit= sublist.iterator();
    while(subit.hasNext()){
       System.out.print(subit.next()+" ");
    }
 
    /* The changes you made to the sublist will affect the     original LinkedList
     * Let’s take this example - We
     * will remove the element "Node 4" from the sublist.
     * Then we will print the original LinkedList. 
     * Node 4 will not be in the original LinkedList too. 
     */
    sublist.remove("Node 4");
    System.out.println("\nElements of the LinkedList LinkedList After removing Node 4:");
    Iterator it2= linkedlist.iterator();
    while(it2.hasNext()){
       System.out.print(it2.next()+" ");
    }
 }
}

A saída ficará assim:

O que acontecerá se os índices estiverem fora do limite em subList ()?

O método subList retorna dois tipos de exceções. Vamos dar uma olhada neles. Considere uma situação se os índices especificados estiverem fora do intervalo do elemento List (fromIndex < 0 || toIndex > size) . Em seguida, lançará um IndexOutOfBoundExecption .

//using subList() method with fromIndex <0 
ArrayList new_list2 = new ArrayList(list.subList(-1, 3));
System.out.println("Portion of the list: "+new_list2);
 
Exception in thread "main" java.lang.IndexOutOfBoundsException: fromIndex = -1
 
// using subList() method with toIndex > size
ArrayList new_list2 = new ArrayList(list.subList(3, 6));
System.out.println("Portion of the list: "+new_list2);
 
Exception in thread "main" java.lang.IndexOutOfBoundsException: toIndex = 6

Além disso, se fromIndex for maior que toIndex (fromIndex > toIndex) , o método subList() lançará um erro IllegalArgumentException .

//If fromIndex > toIndex
ArrayList new_list2 = new ArrayList(list.subList(5, 3));
System.out.println("Portion of the list: "+new_list2);
 
Exception in thread "main" java.lang.IllegalArgumentException: fromIndex(5) > toIndex(3)

Conclusão

Neste artigo, discutimos o método subList e como usá-lo. O método subList() elimina a necessidade de operações de intervalo explícitas (é um tipo de operação que normalmente existe para arrays). A coisa mais importante a lembrar é que o método subList não retorna uma nova instância, mas uma exibição com uma referência à lista original. Portanto, o uso excessivo do método subList na mesma lista pode causar um encadeamento travado em seu aplicativo Java.