Méthode Sublist() en Java : ArrayList et List

Qu'est-ce que la méthode subList() ?

Le cadre des collections est un composant très populaire de l'API Java. L'interface de liste et la classe ArrayList sont probablement les outils les plus importants dans le cadre des collections. subList est une méthode de l'interface List qui vous permet de créer une nouvelle liste à partir d'une partie d'une liste existante. Cependant, cette liste nouvellement créée n'est qu'une vue avec une référence à la liste d'origine. Prenons par exemple la liste de [1,2,3,4,5,6]. Supposons que vous vouliez créer une nouvelle liste sans les premier et dernier éléments. Dans un tel scénario, la méthode list.subList() vous aidera. La méthode subList(fromIndex, toIndex) n'a qu'une seule forme et prend deux arguments, qui sont le premier index (fromIndex) et le dernier index(versIndex) . Il renverra la partie entre le fromIndex et le toIndex comme une nouvelle liste. Il y a un point important à retenir. La liste nouvellement créée inclura le fromIndex et exclura le toIndex. Ainsi, l'algorithme pour le scénario ci-dessus ressemblera à ceci. List = [1,2,3,4,5,6] newList = List.subList(1,5) Étant donné que subList est une méthode de l'interface List, vous pouvez l'utiliser sur les objets ArrayList, LinkedList, Stack et Vector. Cependant, dans cet article, nous nous concentrerons principalement sur les objets ArrayList et LinkedList.

Exemple de la méthode subList sur un objet ArrayList.

Nous déclarons une ArrayList de pays. Ensuite, nous essayons de retourner la partie entre les 2e et 4e éléments.

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 sortie du code ci-dessus sera Dans une ArrayList, la valeur d'index du premier élément est 0. Par conséquent, les valeurs d'index des deuxième et quatrième éléments sont 1 et 3 respectivement. Donc, nous invoquons la méthode sublist() comme list.subList(1, 3) . Cependant, rappelez-vous que la méthode subList renvoie la partie excluant le toIndex qui est le quatrième élément ("Allemagne") dans ce cas. Ainsi, il n'affichera que "UK" et "France" . Étant donné que la sortie renvoyée est une liste elle-même, vous pouvez appeler directement n'importe quelle méthode List sur celle-ci. Que se passera-t-il si nous utilisons le même index pour les deux paramètres ? Cet index sera-t-il inclus ou exclu dans la liste renvoyée ? Découvrons-le.

//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 sortie est La sortie est une liste vide. Même si fromIndex sélectionne le 4ème élément, la méthode subList() le supprimera car c'est aussi le toIndex.

Exemple de la méthode subList sur un objet LinkedList.

Dans cet exemple, nous utiliserons la méthode sublist sur un élément LinkedList. Encore une fois, il renverra la liste entre l'index spécifié fromIndex(inclusive) et toIndex(exclusive) . N'oubliez pas que nous avons dit que la liste renvoyée par la méthode subList() n'est qu'une vue qui fait référence à la liste d'origine. Si vous apportez des modifications à la sous-liste, cela affectera également la liste d'origine. Nous allons également tester cela dans cet exemple.

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 sortie ressemblera à ceci :

Que se passera-t-il si les index sont hors limites dans subList() ?

La méthode subList renvoie deux types d'exceptions. Jetons un coup d'œil à eux. Considérez une situation si les index spécifiés sont hors de la plage de l'élément List (fromIndex < 0 || toIndex > size) . Ensuite, il lancera une 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

De plus, si fromIndex est supérieur à toIndex (fromIndex > toIndex) , la méthode subList() génère une erreur 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)

Conclusion

Dans cet article, nous avons discuté de la méthode subList et de son utilisation. La méthode subList() élimine le besoin d'opérations de plage explicites (c'est un type d'opérations qui existent couramment pour les tableaux). La chose la plus importante à retenir est que la méthode subList ne renvoie pas une nouvelle instance mais une vue avec une référence à la liste d'origine. Par conséquent, l'utilisation excessive de la méthode subList sur la même liste peut entraîner le blocage d'un thread dans votre application Java.