Sublist() Metod i Java: ArrayList och List

Vad är metoden subList()?

Collections Framework är en mycket populär komponent i Java API. Listgränssnitt och ArrayList-klassen är förmodligen de viktigaste verktygen i Collections Framework. subList är en metod i listgränssnittet som låter dig skapa en ny lista från en del av en befintlig lista. Denna nyskapade lista är dock bara en vy med en referens till den ursprungliga listan. Ta till exempel listan med [1,2,3,4,5,6]. Anta att du vill skapa en ny lista utan de första och sista elementen. I ett sådant scenario kommer metoden list.subList() att hjälpa dig. subList(fromIndex, toIndex) -metoden har bara en form och den tar två argument, som är det första indexet (fromIndex) och det sista indexet(toIndex) . Det kommer att returnera delen mellan fromIndex och toIndex som en ny lista. Det finns en viktig punkt att komma ihåg. Den nyskapade listan kommer att inkludera fromIndex och exkludera toIndex. Så algoritmen för ovanstående scenario kommer att vara ungefär så här. List = [1,2,3,4,5,6] newList = List.subList(1,5) Eftersom subList är en metod för listgränssnitt kan du använda den på ArrayList, LinkedList, Stack och Vector-objekt. Men i den här artikeln kommer vi främst att fokusera på ArrayList- och LinkedList-objekt.

Exempel på subList-metoden på ett ArrayList-objekt.

Vi deklarerar en ArrayList över länder. Sedan försöker vi returnera delen mellan 2:a och 4:e elementet.

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

Utdata från ovanstående kod kommer att vara I en ArrayList är indexvärdet för det första elementet 0. Därför är indexvärdena för det andra och fjärde elementet 1 respektive 3. Så vi anropar sublist() -metoden som list.subList(1, 3) . Kom dock ihåg att subList-metoden returnerar delen exklusive toIndex som är det fjärde elementet (" Tyskland") i detta fall. Den kommer alltså endast att mata ut "UK" och "Frankrike" . Eftersom den returnerade utgången är en lista i sig kan du anropa alla listmetoder direkt på den. Så vad händer om vi använder samma index för båda parametrarna? Kommer det indexet att inkluderas eller exkluderas i den returnerade listan? Låt oss ta reda på.

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

Utgången är Utgången är en tom lista. Även om fromIndex väljer det 4:e elementet, kommer subList() -metoden att ta bort det eftersom det också är toIndex.

Exempel på subList-metoden på ett LinkedList-objekt.

I det här exemplet kommer vi att använda sublistmetoden på ett LinkedList-element. Återigen kommer det att returnera listan mellan det angivna indexet fromIndex(inclusive) och toIndex(exclusive) . Kom ihåg att vi sa att listan som returneras av metoden subList() bara är en vy som har en referens till den ursprungliga listan. Om du gör några ändringar i underlistan kommer det också att påverka den ursprungliga listan. Vi kommer att testa det också i det här exemplet.

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

Utgången kommer att se ut så här:

Vad händer om indexen är out of bound i subList()?

SubList - metoden returnerar två typer av undantag. Låt oss ta en titt på dem. Tänk på en situation om de angivna indexen ligger utanför intervallet för List-elementet ( fromIndex < 0 || tillIndex > storlek) . Sedan kommer det att kasta 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

Dessutom, om fromIndex är större än toIndex (fromIndex > toIndex) , ger metoden subList() ett IllegalArgumentException - fel .

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

Slutsats

I den här artikeln diskuterade vi subList- metoden och hur man använder den. subList() -metoden eliminerar behovet av explicita intervalloperationer (det är en typ av operationer som vanligtvis finns för arrayer). Det viktigaste att komma ihåg är att subList-metoden inte returnerar en ny instans utan en vy med en referens till den ursprungliga listan. Därför kan överanvändning av subList -metoden på samma lista orsaka att en tråd fastnar i din Java-applikation.