logo

TechCodeview

Listenschnittstelle in Java mit Beispielen

Die List-Schnittstelle in Java bietet eine Möglichkeit, die geordnete Sammlung zu speichern. Es ist eine untergeordnete Schnittstelle von Sammlung . Es handelt sich um eine geordnete Sammlung von Objekten, in denen doppelte Werte gespeichert werden können. Da List die Einfügereihenfolge beibehält, ermöglicht es den Positionszugriff und das Einfügen von Elementen.

Inhaltsverzeichnis



Listenschnittstelle in Java

Die List-Schnittstelle befindet sich im Paket java.util und erbt die Collection-Schnittstelle. Es ist eine Factory der ListIterator-Schnittstelle. Mit dem ListIterator können wir die Liste in Vorwärts- und Rückwärtsrichtung iterieren. Die Implementierungsklassen der List-Schnittstelle sind ArrayList, LinkedList, Stack und Vector. ArrayList und LinkedList werden häufig in der Java-Programmierung verwendet. Die Vector-Klasse ist seit Java 5 veraltet.

Liste und ArrayList im Java Collection Framework

Deklaration der Java List Interface 

public interface List extends Collection ;>

Lassen Sie uns näher auf die Erstellung von Objekten oder Instanzen in einer List-Klasse eingehen. Seit Aufführen ist ein Schnittstelle , können keine Objekte vom Typ Liste angelegt werden. Wir brauchen immer eine Klasse, die das umsetzt Aufführen um ein Objekt zu erstellen. Und auch nach der Einführung von Generika In Java 1.5 ist es möglich, den Objekttyp einzuschränken, der in der Liste gespeichert werden kann. Genau wie mehrere andere benutzerdefinierte „Schnittstellen“, die von benutzerdefinierten „Klassen“ implementiert werden, Aufführen ist eine „Schnittstelle“, die von der implementiert wird Anordnungsliste Klasse, vordefiniert in java.util Paket.



Syntax der Java-Liste

Diese Art von Safelist kann wie folgt definiert werden:

List list = new ArrayList ();>

Notiz: Obj ist der Typ des Objekts, das in List gespeichert werden soll

Beispiel einer Java-Liste

Java






// Java program to Demonstrate List Interface> > // Importing all utility classes> import> java.util.*;> > // Main class> // ListDemo class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an object of List interface> >// implemented by the ArrayList class> >List l1 =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom inputs> > >l1.add(>0>,>1>);> >l1.add(>1>,>2>);> > >// Print the elements inside the object> >System.out.println(l1);> > >// Now creating another object of the List> >// interface implemented ArrayList class> >// Declaring object of integer type> >List l2 =>new> ArrayList();> > >// Again adding elements to object of List interface> >// Custom inputs> >l2.add(>1>);> >l2.add(>2>);> >l2.add(>3>);> > >// Will add list l2 from 1 index> >l1.addAll(>1>, l2);> > >System.out.println(l1);> > >// Removes element from index 1> >l1.remove(>1>);> > >// Printing the updated List 1> >System.out.println(l1);> > >// Prints element at index 3 in list 1> >// using get() method> >System.out.println(l1.get(>3>));> > >// Replace 0th element with 5> >// in List 1> >l1.set(>0>,>5>);> > >// Again printing the updated List 1> >System.out.println(l1);> >}> }> 

>

>

Ausgabe 

[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>

Lassen Sie uns nun verschiedene Vorgänge mithilfe der Listenschnittstelle ausführen, um diese besser zu verstehen. Wir werden die folgenden unten aufgeführten Vorgänge besprechen und sie später über saubere Java-Codes implementieren.

Operationen in einer Java-Listenschnittstelle

Da List eine Schnittstelle ist, kann sie nur mit einer Klasse verwendet werden, die diese Schnittstelle implementiert. Sehen wir uns nun an, wie Sie einige häufig verwendete Operationen für die Liste ausführen.

  • Vorgang 1: Hinzufügen von Elementen zur List-Klasse mithilfe der Methode add()
  • Vorgang 2: Aktualisieren von Elementen in der List-Klasse mithilfe der set()-Methode
  • Vorgang 3: Suchen nach Elementen mit den Methoden indexOf() und lastIndexOf
  • Vorgang 4: Elemente mit der Methode „remove()“ entfernen
  • Vorgang 5: Zugriff auf Elemente in der List-Klasse mit der Methode get()
  • Vorgang 6: Mit der Methode „contains()“ wird überprüft, ob ein Element in der List-Klasse vorhanden ist

Lassen Sie uns nun die Operationen einzeln besprechen und im Code implementieren, um sie besser im Griff zu haben.

1. Elemente zur List-Klasse hinzufügen mit add()-Methode

Um der Liste ein Element hinzuzufügen, können wir das verwenden hinzufügen() Methode. Diese Methode ist überladen, um mehrere Vorgänge basierend auf unterschiedlichen Parametern auszuführen.

Parameter: Es werden zwei Parameter benötigt, nämlich:

  • add(Objekt): Mit dieser Methode wird ein Element am Ende der Liste hinzugefügt.
  • add(int index, Object): Mit dieser Methode wird ein Element an einem bestimmten Index in der Liste hinzugefügt

Beispiel:

Java

Arrayliste in Java sortieren




// Java Program to Add Elements to a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom elements> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'For'>);> > >// Print all the elements inside the> >// List interface object> >System.out.println(al);> >}> }> 

>

>

Ausgabe 

[Geeks, For, Geeks]>

2. Elemente aktualisieren

Wenn wir nach dem Hinzufügen der Elemente das Element ändern möchten, können wir dies mit dem tun Satz() Methode. Da List indiziert ist, wird das Element, das wir ändern möchten, durch den Index des Elements referenziert. Daher benötigt diese Methode einen Index und das aktualisierte Element, das an diesem Index eingefügt werden muss.

Beispiel:

Java




// Java Program to Update Elements in a List> > // Importing utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface> >List al =>new> ArrayList();> > >// Adding elements to object of List class> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'Geeks'>);> > >// Display theinitial elements in List> >System.out.println(>'Initial ArrayList '> + al);> > >// Setting (updating) element at 1st index> >// using set() method> >al.set(>1>,>'For'>);> > >// Print and display the updated List> >System.out.println(>'Updated ArrayList '> + al);> >}> }> 

>

>

Ausgabe 

Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>

3. Auf der Suche nach Elementen

Die Suche nach Elementen in der List-Schnittstelle ist ein häufiger Vorgang in der Java-Programmierung. Die List-Schnittstelle bietet mehrere Methoden zum Suchen nach Elementen, z Index von() , lastIndexOf() Methoden.

Die Methode indexOf() gibt den Index des ersten Vorkommens eines angegebenen Elements in der Liste zurück, während die Methode lastIndexOf() den Index des letzten Vorkommens eines angegebenen Elements zurückgibt.

Parameter:

  • indexOf(element): Gibt den Index des ersten Vorkommens des angegebenen Elements in der Liste zurück oder -1, wenn das Element nicht gefunden wird
  • lastIndexOf(element): Gibt den Index des letzten Vorkommens des angegebenen Elements in der Liste zurück oder -1, wenn das Element nicht gefunden wird

Beispiel:

Java




import> java.util.ArrayList;> import> java.util.List;> > public> class> ListExample {> >public> static> void> main(String[] args)> >{> >// create a list of integers> >List numbers =>new> ArrayList();> > >// add some integers to the list> >numbers.add(>1>);> >numbers.add(>2>);> >numbers.add(>3>);> >numbers.add(>2>);> > >// use indexOf() to find the first occurrence of an> >// element in the list> >int> index = numbers.indexOf(>2>);> >System.out.println(> >'The first occurrence of 2 is at index '> >+ index);> > >// use lastIndexOf() to find the last occurrence of> >// an element in the list> >int> lastIndex = numbers.lastIndexOf(>2>);> >System.out.println(> >'The last occurrence of 2 is at index '> >+ lastIndex);> >}> }> 

>

>

Ausgabe 

The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>

4. Elemente entfernen

Um ein Element aus einer Liste zu entfernen, können wir die verwenden entfernen() Methode. Diese Methode ist überladen, um mehrere Vorgänge basierend auf unterschiedlichen Parametern auszuführen. Sie sind:

Parameter:

  • entfernen(Objekt): Mit dieser Methode können Sie einfach ein Objekt aus der Liste entfernen. Wenn mehrere solcher Objekte vorhanden sind, wird das erste Vorkommen des Objekts entfernt.
  • entfernen(int index): Da eine Liste indiziert ist, nimmt diese Methode einen ganzzahligen Wert an, der einfach das Element entfernt, das an diesem bestimmten Index in der Liste vorhanden ist. Nach dem Entfernen des Elements werden alle Elemente nach links verschoben, um den Platz zu füllen, und die Indizes der Objekte werden aktualisiert.

Beispiel:

Java

Ram-Schauspieler




// Java Program to Remove Elements from a List> > // Importing List and ArrayList classes> // from java.util package> import> java.util.ArrayList;> import> java.util.List;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> > >// Creating List class object> >List al =>new> ArrayList();> > >// Adding elements to the object> >// Custom inputs> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding For at 1st indexes> >al.add(>1>,>'For'>);> > >// Print the initialArrayList> >System.out.println(>'Initial ArrayList '> + al);> > >// Now remove element from the above list> >// present at 1st index> >al.remove(>1>);> > >// Print the List after removal of element> >System.out.println(>'After the Index Removal '> + al);> > >// Now remove the current object from the updated> >// List> >al.remove(>'Geeks'>);> > >// Finally print the updated List now> >System.out.println(>'After the Object Removal '> >+ al);> >}> }> 

>

>

Ausgabe 

Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>

5. Auf Elemente zugreifen

Um auf ein Element in der Liste zuzugreifen, können wir verwenden erhalten() Methode, die das Element am angegebenen Index zurückgibt

Parameter:

get(int index): Diese Methode gibt das Element am angegebenen Index in der Liste zurück.

Beispiel:

Java




// Java Program to Access Elements of a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Accessing elements using get() method> >String first = al.get(>0>);> >String second = al.get(>1>);> >String third = al.get(>2>);> > >// Printing all the elements inside the> >// List interface object> >System.out.println(first);> >System.out.println(second);> >System.out.println(third);> >System.out.println(al);> >}> }> 

>

>

Ausgabe 

Geeks For Geeks [Geeks, For, Geeks]>

6. Überprüfen, ob ein Element in der Liste vorhanden ist

Um zu überprüfen, ob ein Element in der Liste vorhanden ist, können wir das verwenden enthält() Methode. Diese Methode gibt „true“ zurück, wenn das angegebene Element in der Liste vorhanden ist, andernfalls gibt sie „false“ zurück.

Parameter:

enthält(Objekt): Diese Methode benötigt einen einzelnen Parameter, das zu prüfende Objekt, ob es in der Liste vorhanden ist.

Beispiel:

Java


So deaktivieren Sie den Entwicklermodus in Android



// Java Program to Check if an Element is Present in a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Checking if element is present using contains()> >// method> >boolean> isPresent = al.contains(>'Geeks'>);> > >// Printing the result> >System.out.println(>'Is Geeks present in the list? '> >+ isPresent);> >}> }> 

>

>

Ausgabe 

Is Geeks present in the list? true>

Komplexität der Listenschnittstelle in Java

Betrieb

Zeitkomplexität

Weltraumkomplexität

Element in der Listenschnittstelle hinzufügen

O(1)

O(1)

Element aus der Listenschnittstelle entfernen

AN)

AN)

Element in der Listenschnittstelle ersetzen

AN)

AN)

Traversing-List-Schnittstelle

AN)

AN)

Iterieren über die Listenschnittstelle in Java

Bisher haben wir eine sehr kleine Eingabegröße und führen die Vorgänge für jede Entität manuell durch. Lassen Sie uns nun verschiedene Möglichkeiten besprechen, mit denen wir die Liste durchlaufen können, damit sie für einen größeren Beispielsatz funktioniert.

Methoden: Es gibt mehrere Möglichkeiten, die Liste zu durchlaufen. Die bekanntesten Methoden sind die Verwendung der Basismethode for-Schleife in Kombination mit a get()-Methode um das Element an einem bestimmten Index zu erhalten und das für eine Schleife erweitert .

Beispiel:

Java




// Java program to Iterate the Elements> // in an ArrayList> > // Importing java utility classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// main driver method> >public> static> void> main(String args[])> >{> >// Creating an empty Arraylist of string type> >List al =>new> ArrayList();> > >// Adding elements to above object of ArrayList> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding element at specified position> >// inside list object> >al.add(>1>,>'For'>);> > >// Using for loop for iteration> >for> (>int> i =>0>; i // Using get() method to // access particular element System.out.print(al.get(i) + ' '); } // New line for better readability System.out.println(); // Using for-each loop for iteration for (String str : al) // Printing all the elements // which was inside object System.out.print(str + ' '); } }> 

>

>

Ausgabe 

Geeks For Geeks Geeks For Geeks>

Methoden der Listenschnittstelle

Da das Grundkonzept der verschiedenen Listentypen dasselbe ist, enthält die Listenschnittstelle die folgenden Methoden:

Methode

Beschreibung
add(int index, element) Diese Methode wird mit der Java List Interface verwendet, um ein Element an einem bestimmten Index in der Liste hinzuzufügen. Wenn ein einzelner Parameter übergeben wird, wird das Element einfach am Ende der Liste hinzugefügt.
addAll(int index, Collection-Sammlung) Diese Methode wird mit der List-Schnittstelle in Java verwendet, um alle Elemente in der angegebenen Sammlung zur Liste hinzuzufügen. Wenn ein einzelner Parameter übergeben wird, werden alle Elemente der angegebenen Sammlung am Ende der Liste hinzugefügt.
Größe() Diese Methode wird mit der Java List Interface verwendet, um die Größe der Liste zurückzugeben.
klar() Mit dieser Methode werden alle Elemente in der Liste entfernt. Die Referenz der erstellten Liste bleibt jedoch weiterhin gespeichert.
entfernen(int index) Diese Methode entfernt ein Element aus dem angegebenen Index. Es verschiebt nachfolgende Elemente (falls vorhanden) nach links und verringert ihre Indizes um 1.
(Element) entfernen Diese Methode wird mit der Java List Interface verwendet, um das erste Vorkommen des angegebenen Elements in der Liste zu entfernen.
get(int index) Diese Methode gibt Elemente am angegebenen Index zurück.
set(int index, element) Diese Methode ersetzt Elemente an einem bestimmten Index durch das neue Element. Diese Funktion gibt das Element zurück, das gerade durch ein neues Element ersetzt wurde.
indexOf(element) Diese Methode gibt das erste Vorkommen des angegebenen Elements oder zurück -1 wenn das Element nicht in der Liste vorhanden ist.
lastIndexOf(element) Diese Methode gibt das letzte Vorkommen des angegebenen Elements oder zurück -1 wenn das Element nicht in der Liste vorhanden ist.
gleicht(Element) Diese Methode wird mit der Java List Interface verwendet, um die Gleichheit des angegebenen Elements mit den Elementen der Liste zu vergleichen.
Hash-Code() Diese Methode wird mit List Interface in Java verwendet, um den Hashcode-Wert der angegebenen Liste zurückzugeben.
ist leer() Diese Methode wird mit Java List Interface verwendet, um zu überprüfen, ob die Liste leer ist oder nicht. Es gibt „true“ zurück, wenn die Liste leer ist, andernfalls „false“.
enthält(Element) Diese Methode wird mit der List-Schnittstelle in Java verwendet, um zu überprüfen, ob die Liste das angegebene Element enthält oder nicht. Es gibt true zurück, wenn die Liste das Element enthält.
enthältAlle(Sammlung Sammlung) Diese Methode wird mit der Java List Interface verwendet, um zu überprüfen, ob die Liste die gesamte Elementsammlung enthält.
sort(Komparator comp) Diese Methode wird mit der List-Schnittstelle in Java verwendet, um die Elemente der Liste auf der Grundlage der angegebenen Werte zu sortieren Komparator .

Java-Liste vs. Set

Sowohl die List-Schnittstelle als auch die Set-Schnittstelle erben die Collection-Schnittstelle. Es gibt jedoch einige Unterschiede zwischen ihnen.

Aufführen

Satz
Die Liste ist eine geordnete Sequenz. Die Menge ist eine ungeordnete Folge.
Liste erlaubt doppelte Elemente Set lässt keine doppelten Elemente zu.
Auf Elemente kann über ihre Position zugegriffen werden. Der Positionszugriff auf Elemente ist nicht zulässig.
Es können mehrere Nullelemente gespeichert werden. Das Nullelement kann nur einmal gespeichert werden.
Listenimplementierungen sind ArrayList, LinkedList, Vector, Stack Set-Implementierungen sind HashSet, LinkedHashSet.

Klassenzuordnung mit einer Java-Listenschnittstelle

Lassen Sie uns nun die Klassen besprechen, die die List-Schnittstelle implementieren. Schauen Sie sich zunächst die bildliche Darstellung unten an, um die List-Schnittstelle besser zu verstehen. Es ist wie folgt:

AbstractList , CopyOnWriteArrayList , und das AbstractSequentialList sind die Klassen, die die List-Schnittstelle implementieren. In jeder der genannten Klassen ist eine eigene Funktionalität implementiert. Sie sind wie folgt:

  1. AbstractList: Diese Klasse wird verwendet, um eine nicht veränderbare Liste zu implementieren, für die man nur diese AbstractList-Klasse erweitern und nur die implementieren muss erhalten() und das Größe() Methoden.
  2. CopyOnWriteArrayList: Diese Klasse implementiert die Listenschnittstelle. Es ist eine erweiterte Version von Anordnungsliste Dabei werden alle Änderungen (Hinzufügen, Festlegen, Entfernen usw.) durch Erstellen einer neuen Kopie der Liste implementiert.
  3. AbstractSequentialList: Diese Klasse implementiert die Sammlungsschnittstelle und die AbstractCollection-Klasse. Diese Klasse wird verwendet, um eine nicht veränderbare Liste zu implementieren, für die man nur diese AbstractList-Klasse erweitern und nur die implementieren muss erhalten() und das Größe() Methoden.

Wir werden auf diese Weise vorgehen.

  • Anordnungsliste
  • Vektor
  • Stapel
  • LinkedList

Lassen Sie uns sie der Reihe nach diskutieren und implementieren, um die Funktionsweise der Klassen mit der List-Schnittstelle herauszufinden.

Künstliche Intelligenz und intelligente Agenten

1. ArrayList

Eine ArrayList Die im Collection-Framework implementierte Klasse stellt uns dynamische Arrays in Java zur Verfügung. Es ist zwar möglicherweise langsamer als Standard-Arrays, kann aber in Programmen hilfreich sein, bei denen viele Manipulationen am Array erforderlich sind. Sehen wir uns an, wie man mit dieser Klasse ein Listenobjekt erstellt.

Beispiel:

Java




// Java program to demonstrate the> // creation of list object using the> // ArrayList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of ArrayList> >int> n =>5>;> > >// Declaring the List with initial size n> >List arrli =>new> ArrayList(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >arrli.add(i);> > >// Printing elements> >System.out.println(arrli);> > >// Remove element at index 3> >arrli.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(arrli);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(arrli.get(i) + ' '); } }> 

>

>

Ausgabe 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

2. Vektor

Vector ist eine Klasse, die im Sammlungsframework implementiert ist und ein erweiterbares Array von Objekten implementiert. Vector implementiert ein dynamisches Array, das bedeutet, dass es je nach Bedarf vergrößert oder verkleinert werden kann. Es enthält wie ein Array Komponenten, auf die über einen ganzzahligen Index zugegriffen werden kann. Vektoren fallen grundsätzlich in Legacy-Klassen, sind aber jetzt vollständig mit Sammlungen kompatibel. Sehen wir uns an, wie man mit dieser Klasse ein Listenobjekt erstellt.

Beispiel:

Java




// Java program to demonstrate the> // creation of list object using the> // Vector class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the vector> >int> n =>5>;> > >// Declaring the List with initial size n> >List v =>new> Vector(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >v.add(i);> > >// Printing elements> >System.out.println(v);> > >// Remove element at index 3> >v.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(v);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(v.get(i) + ' '); } }> 

>

>

Ausgabe 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

3. Stapeln

Stack ist eine Klasse, die im Collection-Framework implementiert ist und die Vektorklassenmodelle erweitert und implementiert Beispiel:

Java

Beispiel:

Java




// Java program to demonstrate the> // creation of list object using the> // Stack class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the stack> >int> n =>5>;> > >// Declaring the List> >List s =>new> Stack();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >s.add(i);> > >// Printing elements> >System.out.println(s);> > >// Remove element at index 3> >s.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(s);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(s.get(i) + ' '); } }> 

>

>

Ausgabe 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

4. LinkedList

Beispiel:

Java

LinkedList ist eine Klasse, die im Sammlungsframework implementiert ist, das von Natur aus implementiert Beispiel:

Java

Java rührt zu int
Beispiel:

Java




// Java program to demonstrate the> // creation of list object using the> // LinkedList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the LinkedList> >int> n =>5>;> > >// Declaring the List with initial size n> >List ll =>new> LinkedList();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >ll.add(i);> > >// Printing elements> >System.out.println(ll);> > >// Remove element at index 3> >ll.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(ll);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } }> 

>

>

Ausgabe 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>