Metodo Sublist() in Java: ArrayList e List

Cos'è il metodo subList()?

Il Collections Framework è un componente molto popolare nell'API Java. L'interfaccia List e la classe ArrayList sono probabilmente gli strumenti più importanti nel Collections Framework. subList è un metodo nell'interfaccia List che consente di creare un nuovo elenco da una parte di un elenco esistente. Tuttavia, questo elenco appena creato è solo una vista con un riferimento all'elenco originale. Ad esempio, prendi l'elenco di [1,2,3,4,5,6]. Supponiamo di voler creare un nuovo elenco senza il primo e l'ultimo elemento. In uno scenario del genere, il metodo list.subList() ti aiuterà. Il metodo subList(fromIndex, toIndex) ha una sola forma e accetta due argomenti, che sono il primo indice (fromIndex) e l'ultimo indice(toIndice) . Restituirà la parte tra fromIndex e toIndex come un nuovo elenco. C'è un punto importante da ricordare. L'elenco appena creato includerà fromIndex ed escluderà toIndex. Quindi l'algoritmo per lo scenario precedente sarà qualcosa del genere. List = [1,2,3,4,5,6] newList = List.subList(1,5) Poiché subList è un metodo dell'interfaccia List, è possibile utilizzarlo su oggetti ArrayList, LinkedList, Stack e Vector. Tuttavia, in questo articolo, ci concentreremo principalmente sugli oggetti ArrayList e LinkedList.

Esempio del metodo subList su un oggetto ArrayList.

Stiamo dichiarando un ArrayList di paesi. Quindi proviamo a restituire la porzione tra il 2° e il 4° elemento.

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

L'output del codice precedente sarà In un ArrayList, il valore di indice del primo elemento è 0. Pertanto, i valori di indice del secondo e del quarto elemento sono rispettivamente 1 e 3. Quindi, invochiamo il metodo sublist() come list.subList(1, 3) . Si ricordi però che il metodo subList restituisce la porzione esclusa toIndex che in questo caso è il quarto elemento (“Germany”) . Quindi produrrà solo "Regno Unito" e "Francia" . Poiché l'output restituito è un List stesso, puoi chiamare qualsiasi metodo List direttamente su di esso. Quindi cosa succederà se usiamo lo stesso indice per entrambi i parametri? Tale indice verrà incluso o escluso nell'elenco restituito? Scopriamolo.

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

L'uscita è L'output è un elenco vuoto. Anche se fromIndex seleziona il 4° elemento, il metodo subList() lo rimuoverà poiché è anche toIndex.

Esempio del metodo subList su un oggetto LinkedList.

In questo esempio, utilizzeremo il metodo sublist su un elemento LinkedList. Ancora una volta, restituirà l'elenco tra l'indice specificato fromIndex(inclusive) e toIndex(exclusive) . Ricorda che abbiamo detto che la lista restituita dal metodo subList() è solo una vista che ha un riferimento alla lista originale. Eventuali modifiche apportate alla sottolista influiranno anche sulla lista originale. Verificheremo anche questo in questo esempio.

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

L'output sarà simile a questo:

Cosa accadrà se gli indici sono fuori limite in subList()?

Il metodo subList restituisce due tipi di eccezioni. Diamo un'occhiata a loro. Si consideri una situazione in cui gli indici specificati non rientrano nell'intervallo dell'elemento List (fromIndex < 0 || toIndex > size) . Quindi genererà un 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

Inoltre, se fromIndex è maggiore di toIndex (fromIndex > toIndex) , il metodo subList() genera un errore 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)

Conclusione

In questo articolo, abbiamo discusso il metodo subList e come usarlo. Il metodo subList() elimina la necessità di operazioni di intervallo esplicite (è un tipo di operazioni che esistono comunemente per gli array). La cosa più importante da ricordare è che il metodo subList non restituisce una nuova istanza ma una vista con un riferimento all'elenco originale. Pertanto, l'uso eccessivo del metodo subList nello stesso elenco può causare il blocco di un thread nell'applicazione Java.