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.![Sublist()-metode i Java: ArrayList og List - 1](https://cdn.codegym.cc/images/article/ba2d4d34-7667-47fa-95da-dc98d0d69341/800.jpeg)
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