Sublist() Metode i Java: ArrayList og List

Hva er subList()-metoden?

The Collections Framework er en veldig populær komponent i Java API. Listegrensesnitt og ArrayList-klassen er sannsynligvis de viktigste verktøyene i Collections Framework. subList er en metode i listegrensesnittet som lar deg lage en ny liste fra en del av en eksisterende liste. Denne nyopprettede listen er imidlertid bare en visning med en referanse til den opprinnelige listen. Ta for eksempel listen over [1,2,3,4,5,6]. Anta at du vil lage en ny liste uten de første og siste elementene. I et slikt scenario vil list.subList() -metoden hjelpe deg. subList(fromIndex, toIndex) -metoden har bare én form og den tar to argumenter, som er den første indeksen (fromIndex) og den siste indeksen(toIndex) . Den vil returnere delen mellom fromIndex og toIndex som en ny liste. Det er et viktig poeng å huske. Den nyopprettede listen vil inkludere fromIndex og ekskludere toIndex. Så algoritmen for scenariet ovenfor vil være noe sånt som dette. List = [1,2,3,4,5,6] newList = List.subList(1,5) Siden subList er en metode for List-grensesnitt, kan du bruke den på ArrayList, LinkedList, Stack og Vector-objekter. I denne artikkelen vil vi imidlertid hovedsakelig fokusere på ArrayList- og LinkedList-objekter.

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

Vi erklærer en ArrayList over land. Deretter prøver vi å returnere delen mellom 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);
    }
 }

Utgangen av koden ovenfor vil være I en ArrayList er indeksverdien til det første elementet 0. Derfor er indeksverdiene til det andre og fjerde elementet henholdsvis 1 og 3. Så vi påkaller sublist() -metoden som list.subList(1, 3) . Husk imidlertid at subList-metoden returnerer delen ekskludert toIndex som er det fjerde elementet ("Tyskland") i dette tilfellet. Dermed vil den bare sende ut "UK" og "Frankrike" . Siden den returnerte utgangen er en liste i seg selv, kan du kalle alle listemetoder direkte på den. Så hva vil skje hvis vi bruker samme indeks for begge parameterne? Vil den indeksen bli inkludert eller ekskludert i den returnerte listen? La oss finne det ut.

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

Utgangen er Utgangen er en tom liste. Selv om fromIndex velger det fjerde elementet, vil subList() -metoden fjerne det siden det også er toIndex.

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

I dette eksemplet vil vi bruke underlistemetoden på et LinkedList-element. Igjen vil den returnere listen mellom den angitte indeksen fraIndex(inclusive) og toIndex(exclusive) . Husk at vi sa at listen returnert av subList() -metoden bare er en visning som har en referanse til den opprinnelige listen. Hvis du gjør noen endringer i underlisten, vil det også påvirke den opprinnelige listen. Vi vil teste det også i dette eksemplet.

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

Utgangen vil se slik ut:

Hva vil skje hvis indeksene er ute av bindingen i subList()?

SubList - metoden returnerer to typer unntak. La oss ta en titt på dem. Tenk på en situasjon hvis de angitte indeksene er utenfor rekkevidden til List-elementet (fromIndex < 0 || toIndex > size) . Deretter vil den 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

Dessuten, hvis fromIndex er større enn toIndex (fromIndex > toIndex) , gir subList()- metoden en IllegalArgumentException- feil.

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

Konklusjon

I denne artikkelen diskuterte vi subList- metoden og hvordan du bruker den. subList() -metoden eliminerer behovet for eksplisitte rekkeviddeoperasjoner (det er en type operasjoner som vanligvis eksisterer for arrays). Det viktigste å huske er at subList-metoden ikke returnerer en ny forekomst, men en visning med en referanse til den opprinnelige listen. Derfor kan overbruk av subList -metoden på samme liste føre til at en tråd sitter fast i Java-applikasjonen.