Sublist() Methode in Java: ArrayList en List

Wat is de methode subList()?

Het Collections Framework is een zeer populaire component in Java API. List-interface en ArrayList-klasse zijn waarschijnlijk de belangrijkste tools in het Collections Framework. subList is een methode in de List-interface waarmee u een nieuwe lijst kunt maken van een deel van een bestaande lijst. Deze nieuw aangemaakte lijst is echter slechts een weergave met een verwijzing naar de originele lijst. Neem bijvoorbeeld de lijst van [1,2,3,4,5,6]. Stel dat u een nieuwe lijst wilt maken zonder de eerste en laatste elementen. In een dergelijk scenario zal de methode list.subList() u helpen. subList(fromIndex, toIndex) methode heeft slechts één vorm en er zijn twee argumenten nodig, namelijk de eerste index (fromIndex) en de laatste index(naarIndex) . Het retourneert het gedeelte tussen de fromIndex en de toIndex als een nieuwe lijst. Er is een belangrijk punt om te onthouden. De nieuw gemaakte lijst zal de fromIndex bevatten en de toIndex uitsluiten. Dus het algoritme voor het bovenstaande scenario zal ongeveer zo zijn. List = [1,2,3,4,5,6] newList = List.subList(1,5) Aangezien subList een methode van de List-interface is, kunt u deze gebruiken op ArrayList-, LinkedList-, Stack- en Vector-objecten. In dit artikel zullen we ons echter vooral richten op ArrayList- en LinkedList-objecten.

Voorbeeld van de subList-methode op een ArrayList-object.

We declareren een ArrayList van landen. Vervolgens proberen we het gedeelte tussen het 2e en 4e element terug te geven.

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

De uitvoer van de bovenstaande code zal zijn In een ArrayList is de indexwaarde van het eerste element 0. Daarom zijn de indexwaarden van het tweede en vierde element respectievelijk 1 en 3. We roepen dus de methode sublist() aan als list.subList(1, 3) . Onthoud echter dat de subList-methode het gedeelte retourneert exclusief de toIndex, wat in dit geval het vierde element ("Duitsland") is . Het zal dus alleen "VK" en "Frankrijk" uitvoeren . Aangezien de geretourneerde uitvoer zelf een lijst is, kunt u elke lijstmethode er rechtstreeks op aanroepen. Dus wat gebeurt er als we dezelfde index gebruiken voor beide parameters? Wordt die index wel of niet opgenomen in de geretourneerde lijst? Dat zoeken we uit.

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

De uitvoer is De uitvoer is een lege lijst. Hoewel fromIndex het 4e element selecteert, zal de methode subList() het verwijderen omdat het ook de toIndex is.

Voorbeeld van de methode subList op een LinkedList-object.

In dit voorbeeld gebruiken we de methode sublist op een LinkedList-element. Nogmaals, het retourneert de lijst tussen de opgegeven index fromIndex(inclusive) en toIndex(exclusive) . Onthoud dat we zeiden dat de lijst die wordt geretourneerd door de methode subList() slechts een weergave is die verwijst naar de oorspronkelijke lijst. Als u wijzigingen aanbrengt in de sublijst, heeft dit ook invloed op de oorspronkelijke lijst. Ook dat gaan we testen in dit voorbeeld.

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

De uitvoer ziet er als volgt uit:

Wat gebeurt er als de indexen niet gebonden zijn in subList()?

De methode subList retourneert twee typen uitzonderingen. Laten we ze eens bekijken. Overweeg een situatie waarin de opgegeven indexen buiten het bereik van het List-element vallen (fromIndex < 0 || toIndex > size) . Dan zal het een IndexOutOfBoundExecption genereren .

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

Als de fromIndex groter is dan de toIndex (fromIndex > toIndex) , genereert de methode subList() een IllegalArgumentException- fout.

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

Conclusie

In dit artikel hebben we de subList- methode besproken en hoe deze te gebruiken. De methode subList() elimineert de noodzaak van expliciete bereikbewerkingen (dit is een type bewerking dat gewoonlijk bestaat voor arrays). Het belangrijkste om te onthouden is dat de methode subList geen nieuwe instantie retourneert, maar een weergave met een verwijzing naar de oorspronkelijke lijst. Daarom kan het overmatig gebruik van de subList -methode in dezelfde lijst ervoor zorgen dat er een thread vastloopt in uw Java-toepassing.