Wat is de methode subList()?
Het Collections Framework is een zeer populaire component in Java API. List-interface en ArrayList-klasse zijn waarschijnlijk de belangrijkste tools in het Collections Framework. subList is een methode in de List-interface waarmee u een nieuwe lijst kunt maken van een deel van een bestaande lijst. Deze nieuw aangemaakte lijst is echter slechts een weergave met een verwijzing naar de originele lijst.
Voorbeeld van de subList-methode op een ArrayList-object.
We declareren een ArrayList van landen. Vervolgens proberen we het gedeelte tussen het 2e en 4e element terug te geven.
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);
}
}
De uitvoer van de bovenstaande code zal zijn
Lijst met landen: [VS, VK, Frankrijk, Duitsland, Rusland] De sublijst van de lijst: [VK, Frankrijk]
In een ArrayList is de indexwaarde van het eerste element 0. Daarom zijn de indexwaarden van het tweede en vierde element respectievelijk 1 en 3. We roepen dus de methode sublist() aan als list.subList(1, 3) . Onthoud echter dat de subList-methode het gedeelte retourneert exclusief de toIndex, wat in dit geval het vierde element ("Duitsland") is . Het zal dus alleen "VK" en "Frankrijk" uitvoeren . Aangezien de geretourneerde uitvoer zelf een lijst is, kunt u elke lijstmethode er rechtstreeks op aanroepen. Dus wat gebeurt er als we dezelfde index gebruiken voor beide parameters? Wordt die index wel of niet opgenomen in de geretourneerde lijst? Dat zoeken we uit.
//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);
De uitvoer is
De sublijst van de lijst: [ ]
De uitvoer is een lege lijst. Hoewel fromIndex het 4e element selecteert, zal de methode subList() het verwijderen omdat het ook de toIndex is.
Voorbeeld van de methode subList op een LinkedList-object.
In dit voorbeeld gebruiken we de methode sublist op een LinkedList-element. Nogmaals, het retourneert de lijst tussen de opgegeven index fromIndex(inclusive) en toIndex(exclusive) . Onthoud dat we zeiden dat de lijst die wordt geretourneerd door de methode subList() slechts een weergave is die verwijst naar de oorspronkelijke lijst. Als u wijzigingen aanbrengt in de sublijst, heeft dit ook invloed op de oorspronkelijke lijst. Ook dat gaan we testen in dit voorbeeld.
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()+" ");
}
}
}
De uitvoer ziet er als volgt uit:
Elementen van de LinkedList: Knooppunt 1 Knooppunt 2 Knooppunt 3 Knooppunt 4 Knooppunt 5 Knooppunt 6 Knooppunt 7 Elementen van de sublijst: Knooppunt 3 Knooppunt 4 Knooppunt 5 Elementen van de LinkedList LinkedList Na het verwijderen van Knooppunt 4: Knooppunt 1 Knooppunt 2 Knooppunt 3 Knooppunt 5 Knooppunt 6 Knooppunt 7
Wat gebeurt er als de indexen niet gebonden zijn in subList()?
De methode subList retourneert twee typen uitzonderingen. Laten we ze eens bekijken. Overweeg een situatie waarin de opgegeven indexen buiten het bereik van het List-element vallen (fromIndex < 0 || toIndex > size) . Dan zal het een IndexOutOfBoundExecption genereren .
//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
Als de fromIndex groter is dan de toIndex (fromIndex > toIndex) , genereert de methode subList() een IllegalArgumentException- fout.
//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)
Conclusie
In dit artikel hebben we de subList- methode besproken en hoe deze te gebruiken. De methode subList() elimineert de noodzaak van expliciete bereikbewerkingen (dit is een type bewerking dat gewoonlijk bestaat voor arrays). Het belangrijkste om te onthouden is dat de methode subList geen nieuwe instantie retourneert, maar een weergave met een verwijzing naar de oorspronkelijke lijst. Daarom kan het overmatig gebruik van de subList -methode in dezelfde lijst ervoor zorgen dat er een thread vastloopt in uw Java-toepassing.
Meer lezen: |
---|
GO TO FULL VERSION