Mi az a subList() metódus?
A Collections Framework egy nagyon népszerű összetevő a Java API-ban. A List interfész és az ArrayList osztály valószínűleg a legfontosabb eszközök a Collections Frameworkben. A subList egy olyan módszer a Lista felületen, amely lehetővé teszi új lista létrehozását egy meglévő lista egy részéből. Ez az újonnan létrehozott lista azonban csak egy nézet az eredeti listára való hivatkozással.
Példa a subList metódusra egy ArrayList objektumon.
Az országok ArrayListjét hirdetjük ki. Ezután megpróbáljuk visszaadni a 2. és 4. elem közötti részt.
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);
}
}
A fenti kód kimenete lesz
Az országok listája:[USA, Egyesült Királyság, Franciaország, Németország, Oroszország] A lista allistája: [Egyesült Királyság, Franciaország]
Egy ArrayListben az első elem indexértéke 0. Ezért a második és negyedik elem indexértéke 1, illetve 3. Tehát a sublist() metódust list.subList(1, 3) néven hívjuk meg . Ne feledje azonban, hogy a subList metódus azt a részt adja vissza, amely kizárja a toIndexet, amely ebben az esetben a negyedik elem („Németország”) . Így csak az „Egyesült Királyság” és „Franciaország” szavakat adja ki . Mivel a visszaadott kimenet maga egy lista, bármelyik List metódus közvetlenül meghívható rajta. Tehát mi történik, ha ugyanazt az indexet használjuk mindkét paraméterhez? Ez az index szerepelni fog vagy ki lesz zárva a visszaadott listából? Találjuk ki.
//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);
A kimenet az
A lista allistája: [ ]
A kimenet egy üres lista. Annak ellenére, hogy a fromIndex kiválasztja a 4. elemet, a subList() metódus eltávolítja azt, mivel ez egyben a toIndex is.
Példa a subList metódusra egy LinkedList objektumon.
Ebben a példában az allista módszert fogjuk használni egy LinkedList elemen. Ismét visszaadja a listát a megadott index fromIndex(inclusive) és toIndex(exclusive) között . Ne feledje, hogy azt mondtuk, hogy a subList() metódus által visszaadott lista csak egy nézet, amely az eredeti listára hivatkozik. Ha bármilyen változtatást végez az allistán, az az eredeti listát is érinti. Ebben a példában ezt is teszteljük.
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()+" ");
}
}
}
A kimenet így fog kinézni:
A LinkedList elemei: 1. csomópont 2. csomópont 3. csomópont 4. csomópont 5. csomópont 6. csomópont 7. csomópont Az allista elemei: 3. csomópont 4. csomópont 5. csomópont A LinkedList elemei LinkedList A 4. csomópont eltávolítása után: 1. csomópont 2. csomópont 3. csomópont 5. csomópont 7. csomópont
Mi történik, ha az indexek túllépnek a subList()-ben?
A subList metódus kétféle kivételt ad vissza. Vessünk egy pillantást rájuk. Vegyünk egy olyan helyzetet, amikor a megadott indexek kívül esnek a List elem tartományán (fromIndex < 0 || toIndex > size) . Ezután egy IndexOutOfBoundExecptiont fog dobni .
//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
Továbbá, ha a fromIndex nagyobb, mint a toIndex (fromIndex > toIndex) , a subList() metódus IllegalArgumentException hibát dob .
//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)
Következtetés
Ebben a cikkben a subList módszert és annak használatát tárgyaltuk . A subList() metódus kiküszöböli az explicit tartományműveletek szükségességét (ez egy olyan típusú művelet, amely általában létezik tömböknél). A legfontosabb dolog, amit meg kell jegyeznünk, hogy a subList metódus nem új példányt ad vissza, hanem egy nézetet az eredeti listára való hivatkozással. Ezért a subList metódus túlzott használata ugyanazon a listán egy szál elakadását okozhatja a Java alkalmazásban.
További olvasnivalók: |
---|
GO TO FULL VERSION