Sublist()-Methode in Java: ArrayList und List

Was ist die subList()-Methode?

Das Collections Framework ist eine sehr beliebte Komponente in der Java API. Die Listenschnittstelle und die ArrayList-Klasse sind wahrscheinlich die wichtigsten Werkzeuge im Collections Framework. subList ist eine Methode in der List-Schnittstelle, mit der Sie eine neue Liste aus einem Teil einer vorhandenen Liste erstellen können. Allerdings handelt es sich bei dieser neu erstellten Liste nur um eine Ansicht mit Verweis auf die ursprüngliche Liste. Nehmen Sie zum Beispiel die Liste von [1,2,3,4,5,6]. Angenommen, Sie möchten eine neue Liste ohne das erste und letzte Element erstellen. In einem solchen Szenario hilft Ihnen die Methode list.subList() . Die Methode subList(fromIndex, toIndex) hat nur eine Form und benötigt zwei Argumente, nämlich den ersten Index (fromIndex) und den letzten Index(toIndex) . Der Teil zwischen fromIndex und toIndex wirdals neue Liste zurückgegeben. Es gibt einen wichtigen Punkt, den Sie beachten sollten. Die neu erstellte Liste enthält den fromIndex und schließt den toIndex aus. Der Algorithmus für das obige Szenario wird also ungefähr so ​​aussehen. List = [1,2,3,4,5,6] newList = List.subList(1,5) Da subList eine Methode der List-Schnittstelle ist, können Sie sie für ArrayList-, LinkedList-, Stack- und Vector-Objekte verwenden. In diesem Artikel konzentrieren wir uns jedoch hauptsächlich auf ArrayList- und LinkedList-Objekte.

Beispiel der subList-Methode für ein ArrayList-Objekt.

Wir deklarieren eine ArrayList von Ländern. Dann versuchen wir, den Teil zwischen dem 2. und 4. Element zurückzugeben.

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

Die Ausgabe des obigen Codes wird sein In einer ArrayList ist der Indexwert des ersten Elements 0. Daher sind die Indexwerte des zweiten und vierten Elements 1 bzw. 3. Also rufen wir die Methode sublist() als list.subList(1, 3) auf . Bedenken Sie jedoch, dass die subList-Methode den Teil ohne toIndex zurückgibt, der in diesem Fall das vierte Element („Germany“) ist. Daher werden nur „UK“ und „Frankreich“ ausgegeben. Da die zurückgegebene Ausgabe selbst eine Liste ist, können Sie beliebige Listenmethoden direkt darauf aufrufen. Was passiert also, wenn wir für beide Parameter denselben Index verwenden? Wird dieser Index in die zurückgegebene Liste aufgenommen oder ausgeschlossen? Lass es uns herausfinden.

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

Die Ausgabe ist Die Ausgabe ist eine leere Liste. Auch wenn fromIndex das vierte Element auswählt, wird die Methode subList() es entfernen, da es auch toIndex ist.

Beispiel der subList-Methode für ein LinkedList-Objekt.

In diesem Beispiel verwenden wir die Sublist-Methode für ein LinkedList-Element. Auch hier wird die Liste zwischen dem angegebenen Index fromIndex(inclusive) und toIndex(exclusive) zurückgegeben . Denken Sie daran, dass wir gesagt haben, dass die von der subList()- Methode zurückgegebene Liste nur eine Ansicht ist, die einen Verweis auf die ursprüngliche Liste enthält. Wenn Sie Änderungen an der Unterliste vornehmen, wirkt sich dies auch auf die Originalliste aus. Auch das werden wir in diesem Beispiel testen.

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

Die Ausgabe sieht folgendermaßen aus:

Was passiert, wenn die Indizes in subList() außerhalb der Grenzen liegen?

Die subList- Methode gibt zwei Arten von Ausnahmen zurück. Werfen wir einen Blick darauf. Stellen Sie sich eine Situation vor, in der die angegebenen Indizes außerhalb des Bereichs des Listenelements liegen (fromIndex < 0 || toIndex > size) . Dann wird eine IndexOutOfBoundExecption ausgelöst .

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

Wenn außerdem fromIndex größer als toIndex (fromIndex > toIndex) ist , löst die Methode subList() einen IllegalArgumentException- Fehler aus.

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

Abschluss

In diesem Artikel haben wir die subList- Methode und ihre Verwendung besprochen. Die Methode subList() macht explizite Bereichsoperationen überflüssig (dies ist eine Art von Operationen, die üblicherweise für Arrays vorhanden sind). Das Wichtigste, was Sie sich merken sollten, ist, dass die subList-Methode keine neue Instanz, sondern eine Ansicht mit einem Verweis auf die ursprüngliche Liste zurückgibt. Daher kann eine übermäßige Verwendung der subList- Methode in derselben Liste dazu führen, dass ein Thread in Ihrer Java-Anwendung hängen bleibt.