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.
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
Liste over landene:[USA, Storbritannia, Frankrike, Tyskland, Russland] Underlisten til listen: [Storbritannia, Frankrike]
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
Underlisten til listen: [ ]
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:
Elementer av LinkedList: Node 1 Node 2 Node 3 Node 4 Node 5 Node 6 Node 7 Elementer av underlisten: Node 3 Node 4 Node 5 Elementer av LinkedList LinkedList Etter fjerning av Node 4: Node 1 Node 2 Node 3 Node 5 Node 6 Node 7
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.
Mer lesing: |
---|
GO TO FULL VERSION