Metoda Sublist() în Java: ArrayList și List

Ce este metoda subList()?

Cadrul de colecții este o componentă foarte populară în API-ul Java. Interfața List și clasa ArrayList sunt probabil cele mai importante instrumente din Cadrul Colecțiilor. subList este o metodă din interfața Listă care vă permite să creați o nouă listă dintr-o porțiune a unei liste existente. Cu toate acestea, această listă nou creată este doar o vizualizare cu o referință la lista originală. De exemplu, luați lista [1,2,3,4,5,6]. Să presupunem că doriți să creați o nouă listă fără primul și ultimul element. Într-un astfel de scenariu, metoda list.subList() vă va ajuta. metoda subList(fromIndex, toIndex) are o singură formă și are două argumente, care sunt primul index (fromIndex) și ultimul index(la Index) . Va returna porțiunea dintre fromIndex și toIndex ca o nouă listă. Există un punct important de reținut. Lista nou creată va include fromIndex și va exclude toIndex. Deci algoritmul pentru scenariul de mai sus va fi cam așa. List = [1,2,3,4,5,6] newList = List.subList(1,5) Deoarece subList este o metodă a interfeței List, o puteți utiliza pe obiectele ArrayList, LinkedList, Stack și Vector. Cu toate acestea, în acest articol, ne vom concentra în principal pe obiectele ArrayList și LinkedList.

Exemplu de metodă subList pe un obiect ArrayList.

Declarăm un ArrayList de țări. Apoi încercăm să returnăm porțiunea dintre al 2-lea și al 4-lea element.

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

Ieșirea codului de mai sus va fi Într-o ArrayList, valoarea indexului primului element este 0. Prin urmare, valorile indexului celui de-al doilea și al patrulea element sunt 1 și, respectiv, 3. Deci, invocăm metoda sublist() ca list.subList(1, 3) . Totuși, rețineți că metoda subList returnează porțiunea, excluzând toIndex, care este al patrulea element („Germania”) în acest caz. Astfel, va scoate doar „Marea Britanie” și „Franța” . Deoarece rezultatul returnat este o listă în sine, puteți apela orice metodă List direct pe ea. Deci, ce se va întâmpla dacă vom folosi același index pentru ambii parametri? Va fi inclus sau exclus acel index în lista returnată? Să aflăm.

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

Ieșirea este Ieșirea este o listă goală. Chiar dacă fromIndex selectează al 4-lea element, metoda subList() îl va elimina deoarece este și toIndex.

Exemplu de metodă subList pe un obiect LinkedList.

În acest exemplu, vom folosi metoda sublist pe un element LinkedList. Din nou, va returna lista dintre indexul specificat fromIndex(inclusiv) și toIndex(exclusive) . Amintiți-vă că am spus că lista returnată de metoda subList() este doar o vizualizare care are o referință la lista originală. Dacă faceți modificări în sublistă, aceasta va afecta și lista originală. Vom testa și asta în acest exemplu.

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

Ieșirea va arăta astfel:

Ce se va întâmpla dacă indicii sunt în afara limitelor în subList()?

Metoda subList returnează două tipuri de excepții. Să aruncăm o privire la ele. Luați în considerare o situație în care indicii specificați sunt în afara intervalului elementului List (fromIndex < 0 || toIndex > size) . Apoi va arunca 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

De asemenea, dacă fromIndex este mai mare decât toIndex (fromIndex > toIndex) , metoda subList() aruncă o eroare 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)

Concluzie

În acest articol, am discutat despre metoda subList și despre cum să o folosim. Metoda subList() elimină necesitatea operațiunilor de interval explicite (Este un tip de operații care există în mod obișnuit pentru matrice). Cel mai important lucru de reținut este că metoda subList nu returnează o instanță nouă, ci o vizualizare cu referință la lista originală. Prin urmare, utilizarea excesivă a metodei subList pe aceeași listă poate cauza blocarea unui fir în aplicația dvs. Java.