Método Sublist() en Java: ArrayList y List

¿Qué es el método subList()?

Collections Framework es un componente muy popular en la API de Java. La interfaz de lista y la clase ArrayList son probablemente las herramientas más importantes en Collections Framework. subList es un método en la interfaz List que le permite crear una nueva lista a partir de una parte de una lista existente. Sin embargo, esta lista recién creada es solo una vista con una referencia a la lista original. Por ejemplo, tome la lista de [1,2,3,4,5,6]. Suponga que desea crear una nueva lista sin el primer y el último elemento. En tal escenario, el método list.subList() lo ayudará. El método subList(fromIndex, toIndex) tiene solo una forma y toma dos argumentos, que son el primer índice (fromIndex) y el último índice(al índice) . Devolverá la parte entre fromIndex y toIndex como una nueva lista. Hay un punto importante a recordar. La lista recién creada incluirá fromIndex y excluirá toIndex. Entonces, el algoritmo para el escenario anterior será algo como esto. List = [1,2,3,4,5,6] newList = List.subList(1,5) Dado que subList es un método de interfaz List, puede usarlo en objetos ArrayList, LinkedList, Stack y Vector. Sin embargo, en este artículo, nos centraremos principalmente en los objetos ArrayList y LinkedList.

Ejemplo del método subList en un objeto ArrayList.

Estamos declarando una ArrayList de países. Luego tratamos de devolver la porción entre los elementos 2 y 4.

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

La salida del código anterior será En una ArrayList, el valor de índice del primer elemento es 0. Por lo tanto, los valores de índice del segundo y cuarto elementos son 1 y 3 respectivamente. Entonces, invocamos el método sublist() como list.subList(1, 3) . Sin embargo, recuerde que el método subList devuelve la parte que excluye toIndex, que es el cuarto elemento ("Alemania") en este caso. Por lo tanto, solo generará "Reino Unido" y "Francia" . Dado que la salida devuelta es una Lista en sí misma, puede llamar a cualquier método de Lista directamente en ella. Entonces, ¿qué sucederá si usamos el mismo índice para ambos parámetros? ¿Se incluirá o excluirá ese índice en la lista devuelta? Vamos a averiguar.

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

La salida es La salida es una lista vacía. Aunque fromIndex selecciona el cuarto elemento, el método subList() lo eliminará ya que también es toIndex.

Ejemplo del método subList en un objeto LinkedList.

En este ejemplo, usaremos el método de sublista en un elemento LinkedList. Nuevamente, devolverá la lista entre el índice especificado fromIndex(inclusive) y toIndex(exclusive) . Recuerde que dijimos que la lista devuelta por el método subList() es solo una vista que tiene una referencia a la lista original. Si realiza algún cambio en la sublista, también afectará a la lista original. Probaremos eso también en este ejemplo.

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()+" ");
    }
 }
}

La salida se verá así:

¿Qué pasará si los índices están fuera de límite en subList()?

El método subList devuelve dos tipos de excepciones. Echemos un vistazo a ellos. Considere una situación si los índices especificados están fuera del rango del elemento List (fromIndex < 0 || toIndex > size) . Luego arrojará una IndexOutOfBoundExeption .

//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

Además, si fromIndex es mayor que toIndex (fromIndex > toIndex) , el método subList() arroja un error 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)

Conclusión

En este artículo, discutimos el método subList y cómo usarlo. El método subList() elimina la necesidad de operaciones de rango explícitas (es un tipo de operaciones que comúnmente existen para matrices). Lo más importante que debe recordar es que el método subList no devuelve una nueva instancia sino una vista con una referencia a la lista original. Por lo tanto, el uso excesivo del método subList en la misma lista puede hacer que un hilo se atasque en su aplicación Java.