Sublist() Metode i Java: ArrayList og List

Hvad er subList()-metoden?

Collections Framework er en meget populær komponent i Java API. List interface og ArrayList klasse er nok de vigtigste værktøjer i Collections Framework. subList er en metode i listegrænsefladen, der lader dig oprette en ny liste fra en del af en eksisterende liste. Denne nyoprettede liste er dog kun en visning med en reference til den oprindelige liste. Tag for eksempel listen over [1,2,3,4,5,6]. Antag, at du vil oprette en ny liste uden de første og sidste elementer. I et sådant scenarie vil list.subList() -metoden hjælpe dig. subList(fromIndex, toIndex) metoden har kun én form, og den tager to argumenter, som er det første indeks (fromIndex) og det sidste indeks(toIndex) . Det vil returnere delen mellem fromIndex og toIndex som en ny liste. Der er en vigtig pointe at huske. Den nyoprettede liste vil inkludere fromIndex og ekskludere toIndex. Så algoritmen for ovenstående scenarie vil være noget som dette. List = [1,2,3,4,5,6] newList = List.subList(1,5) Da subList er en metode til List-interface, kan du bruge den på ArrayList, LinkedList, Stack og Vector-objekter. Men i denne artikel vil vi hovedsageligt fokusere på ArrayList og LinkedList objekter.

Eksempel på subList-metoden på et ArrayList-objekt.

Vi erklærer en ArrayList over lande. Derefter forsøger vi at returnere portionen mellem 2. og 4. 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);
    }
 }

Outputtet af ovenstående kode vil være I en ArrayList er indeksværdien for det første element 0. Derfor er indeksværdierne for det andet og fjerde element henholdsvis 1 og 3. Så vi påberåber os sublist()- metoden som list.subList(1, 3) . Husk dog, at subList-metoden returnerer den del, der ekskluderer toIndex, som er det fjerde element ("Tyskland") i dette tilfælde. Det vil således kun udsende "UK" og "Frankrig" . Da det returnerede output er en liste i sig selv, kan du kalde enhver listemetoder direkte på den. Så hvad vil der ske, hvis vi bruger det samme indeks for begge parametre? Vil det indeks blive inkluderet eller ekskluderet i den returnerede liste? Lad os finde ud af det.

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

Udgangen er Outputtet er en tom liste. Selvom fromIndex vælger det 4. element, vil subList() -metoden fjerne det, da det også er toIndex.

Eksempel på subList-metoden på et LinkedList-objekt.

I dette eksempel vil vi bruge sublist-metoden på et LinkedList-element. Igen vil det returnere listen mellem det angivne indeks fraIndex(inklusiv) og toIndex(eksklusiv) . Husk, at vi sagde, at listen returneret af subList() -metoden kun er en visning, der har en reference til den originale liste. Hvis du foretager ændringer på underlisten, vil det også påvirke den oprindelige liste. Det vil vi også teste i dette eksempel.

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

Outputtet vil se sådan ud:

Hvad vil der ske, hvis indekserne er ude af binding i subList()?

SubList - metoden returnerer to typer undtagelser. Lad os tage et kig på dem. Overvej en situation, hvis de angivne indekser er uden for rækkevidden af ​​List-elementet (fromIndex < 0 || toIndex > size) . Så vil det kaste en 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

Hvis fromIndex er større end toIndex (fromIndex > toIndex) , udløser subList()- metoden en IllegalArgumentException- fejl.

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

Konklusion

I denne artikel diskuterede vi subList- metoden og hvordan man bruger den. subList() metode eliminerer behovet for eksplicitte områdeoperationer (det er en type operationer, der almindeligvis eksisterer for arrays). Det vigtigste at huske er, at subList-metoden ikke returnerer en ny instans, men en visning med en reference til den originale liste. Derfor kan overbrug af subList- metoden på samme liste forårsage, at en tråd sidder fast i din Java-applikation.