Sublist() módszer Java nyelven: ArrayList és List

Mi az a subList() metódus?

A Collections Framework egy nagyon népszerű összetevő a Java API-ban. A List interfész és az ArrayList osztály valószínűleg a legfontosabb eszközök a Collections Frameworkben. A subList egy olyan módszer a Lista felületen, amely lehetővé teszi új lista létrehozását egy meglévő lista egy részéből. Ez az újonnan létrehozott lista azonban csak egy nézet az eredeti listára való hivatkozással. Vegyük például az [1,2,3,4,5,6] listát. Tegyük fel, hogy új listát szeretne létrehozni az első és az utolsó elem nélkül. Ilyen esetben a list.subList() metódus segít. subList(fromIndex, toIndex) metódusnak csak egy formája van, és két argumentumot vesz fel, amelyek az első index (fromIndex) és az utolsó index(toIndex) . A fromIndex és a toIndex közötti részt új listakéntadja visszaVan egy fontos szempont, amit emlékezni kell. Az újonnan létrehozott lista tartalmazza a fromIndexet, és kizárja a toIndexet. Tehát a fenti forgatókönyv algoritmusa valami ilyesmi lesz. List = [1,2,3,4,5,6] newList = List.subList(1,5) Mivel a subList a List interfész metódusa, használhatja ArrayList, LinkedList, Stack és Vector objektumokon. Ebben a cikkben azonban elsősorban az ArrayList és LinkedList objektumokra fogunk összpontosítani.

Példa a subList metódusra egy ArrayList objektumon.

Az országok ArrayListjét hirdetjük ki. Ezután megpróbáljuk visszaadni a 2. és 4. elem közötti részt.

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 fenti kód kimenete lesz Egy ArrayListben az első elem indexértéke 0. Ezért a második és negyedik elem indexértéke 1, illetve 3. Tehát a sublist() metódust list.subList(1, 3) néven hívjuk meg . Ne feledje azonban, hogy a subList metódus azt a részt adja vissza, amely kizárja a toIndexet, amely ebben az esetben a negyedik elem („Németország”) . Így csak az „Egyesült Királyság” és „Franciaország” szavakat adja ki . Mivel a visszaadott kimenet maga egy lista, bármelyik List metódus közvetlenül meghívható rajta. Tehát mi történik, ha ugyanazt az indexet használjuk mindkét paraméterhez? Ez az index szerepelni fog vagy ki lesz zárva a visszaadott listából? Találjuk ki.

//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 kimenet az A kimenet egy üres lista. Annak ellenére, hogy a fromIndex kiválasztja a 4. elemet, a subList() metódus eltávolítja azt, mivel ez egyben a toIndex is.

Példa a subList metódusra egy LinkedList objektumon.

Ebben a példában az allista módszert fogjuk használni egy LinkedList elemen. Ismét visszaadja a listát a megadott index fromIndex(inclusive) és toIndex(exclusive) között . Ne feledje, hogy azt mondtuk, hogy a subList() metódus által visszaadott lista csak egy nézet, amely az eredeti listára hivatkozik. Ha bármilyen változtatást végez az allistán, az az eredeti listát is érinti. Ebben a példában ezt is teszteljük.

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 kimenet így fog kinézni:

Mi történik, ha az indexek túllépnek a subList()-ben?

A subList metódus kétféle kivételt ad vissza. Vessünk egy pillantást rájuk. Vegyünk egy olyan helyzetet, amikor a megadott indexek kívül esnek a List elem tartományán (fromIndex < 0 || toIndex > size) . Ezután egy IndexOutOfBoundExecptiont fog dobni .

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

Továbbá, ha a fromIndex nagyobb, mint a toIndex (fromIndex > toIndex) , a subList() metódus IllegalArgumentException hibát dob .

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

Következtetés

Ebben a cikkben a subList módszert és annak használatát tárgyaltuk . A subList() metódus kiküszöböli az explicit tartományműveletek szükségességét (ez egy olyan típusú művelet, amely általában létezik tömböknél). A legfontosabb dolog, amit meg kell jegyeznünk, hogy a subList metódus nem új példányt ad vissza, hanem egy nézetet az eredeti listára való hivatkozással. Ezért a subList metódus túlzott használata ugyanazon a listán egy szál elakadását okozhatja a Java alkalmazásban.