ArrayList ist ein Teil von Sammlungsrahmen und ist im Paket java.util vorhanden. Es 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 im Array erforderlich sind. Diese Klasse befindet sich in java.util Paket.
Mit der Einführung und den Aktualisierungen in Java-Versionen sind neuere Methoden verfügbar, als ob wir aus Java8 sehen würden, dass perzeptive Lambda-Ausdrücke und Streams-Konzepte zuvor nicht verfügbar waren, da sie in Java-Version8 eingeführt wurden.
Methoden:
Finden Sie gesperrte Nummern auf Android
- Verwendung von for-Schleifen
- Verwenden von while
- Verwendung einer for-each-Schleife
- Verwenden von Iterator
- Verwendung von Lambda-Ausdrücken (nur nach Java8)
- Verwendung der Enumeration-Schnittstelle
Lassen Sie uns diese Methoden diskutieren, von denen wir sofort erkennen können, dass die ersten drei Methoden einfach die naiven Ansätze sind und die weiteren Methoden eine gewisse Optimierung mit sich bringen. Denken Sie daran, dass es zwar weniger durchlaufende Elemente gibt, wir im Allgemeinen jedoch dazu neigen, über einen naiven Ansatz zu iterieren. Wenn die Größe der einzufügenden Elemente groß ist, verwenden wir jedoch optimale Ansätze. Lassen Sie uns jeden der oben genannten Ansätze kurz zusammenfassen.
Methode 1: Verwendung einer for-Schleife
Java
// Java program to iterate over an ArrayList // Using for loop // Importing all utility classes import java.util.*; // Main class class GFG { // Main driver method public static void main(String[] args) { // Creating and initializing the ArrayList // Declaring object of integer type List zahlen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iterieren mit for-Schleife for (int i = 0; i< numbers.size(); i++) // Printing and display the elements in ArrayList System.out.print(numbers.get(i) + ' '); } }> Ausgabe
1 2 3 4 5 6 7 8>
Methode 2: Verwendung der While-Schleife
Java // Java Program to Illustrate ArrayList // Using While Loop // Importing required classes import java.util.ArrayList ; // Main class public class GFG { // Main driver method public static void main(String[] args) { // Creating and initializing the ArrayList // Declaring object of integer type ArrayList al = neue ArrayList (); // Elemente zu ArrayList hinzufügen // mit der add()-Methode al.add(3); al.add(1); al.add(7); al.add(20); al.add(5); // Schritt 1: Setzen und Initialisieren einer Variablen // gemäß der Syntax der While-Schleife // Anfängliches Deklarieren und Setzen von int val = 0; // Schritt 2: Bedingung // Bis unsere Zählervariable kleiner ist als die Größe von // ArrayList while (al.size()> val) { // Das Element drucken, das oben gilt // Bedingung wahr System.out.println(al .get(val)); // Schritt 3: Beenden der Bedingung durch Inkrementieren // unseres Zählers in jeder Iteration val++ ; } } }> Ausgabe
3 1 7 20 5>
Methode 3: Verwendung für jede Schleife
Java // Java Program to Iterate over Arraylist // using for Each loop // Importing all utility classes import java.util.*; // Main class class GFG { // Main driver method public static void main(String[] args) { // Declaring and initializing ArrayList List zahlen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // For Each-Schleife zum Durchlaufen von ArrayList for (Integer i : Zahlen) // Drucken der Elemente von ArrayList System.out.print(i + ' '); } }> Ausgabe
1 2 3 4 5 6 7 8>
Methode 4: Verwenden von Iterator
Java
// Java program to iterate over an ArrayList // Using Iterator // Importing all utility classes import java.util.*; // Main class class GFG { // Main driver method public static void main(String[] args) { // Declaring and initializing ArrayList List zahlen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // ArrayList mit Iterator Iterator iterieren it = zahlen.iterator(); // Hält wahr, bis ein einzelnes Element // in der Liste verbleibt, während (it.hasNext()) // Die Elemente von ArrayList drucken System.out.print(it.next() + ' '); } }> Ausgabe
1 2 3 4 5 6 7 8>
Methode 5: Verwendung von Lambda-Ausdrücken
Java // Java program to iterate over an arraylist // using Iterator in Java8 with Lambda Expression // Importing all utility classes import java.util.*; // Main class class GFG { // Main driver method public static void main(String[] args) { // Declaring and initializing ArrayList // Custom input elements List zahlen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Drucken von Zahlen mit Lambda-Ausdrücken // wurde später in Java8 eingeführt. numbers.forEach(number->System.out.println(number)); } }> Ausgabe
1 2 3 4 5 6 7 8>
Methode 6: Verwendung der Enumeration-Schnittstelle
Java // Java Program to Iterate over ArrayList elements // Using Enumeration // Importing required classes import java.util.ArrayList; import java.util.Collections; import java.util.Enumeration; // Main class class GFG { // Main driver method public static void main(String[] args) { // Creating an ArrayList ArrayList al = neue ArrayList (); // Elemente zur ArrayList hinzufügen al.add(34); al.add(12); al.add(34); al.add(23); al.add(54); // Ein Aufzählungsobjekt abrufen Enumeration e = Collections.enumeration(al); // Bis Elemente vorhanden sind while (e.hasMoreElements()) // Elemente mit der Methode nextElement() drucken System.out.println(e.nextElement()); } }> Ausgabe
34 12 34 23 54>
Jetzt ist es eine weitere Ergänzung zum Artikel, da wir mit der Diskussion aller Methoden fertig sind, die zur Iteration über Elemente verwendet werden können. Bis jetzt haben wir nur Eingabeelemente durchlaufen und noch nicht gesehen, was passiert, wenn wir mit Elementen spielen, also denken wir darüber nach
Beispiel
Java // Java program to demonstrate Working of // Iterator.remove() on Arraylist // Importing utility classes import java.util.List; import java.util.ArrayList; import java.util.Iterator; // Main class public class GFG { // Main driver method public static void main(String[] args) { // Creating a List with referenceto ArrayList List al = neue ArrayList (); al.add(10); al.add(20); al.add(30); al.add(1); al.add(2); // Elemente kleiner als 10 entfernen mit // Iterator.remove() Iterator itr = al.iterator(); while (itr.hasNext()) { int x = (Integer)itr.next(); wenn (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }> Ausgabe
Modified ArrayList : [10, 20, 30]>
Elemente während der Durchquerung entfernen: Es wird nicht empfohlen, ArrayList.remove() beim Durchlaufen von Elementen zu verwenden. Dies kann dazu führen ConcurrentModificationException (Beziehen auf Das für ein Beispielprogramm mit dieser Ausnahme). Bei der Iteration über Elemente wird die Verwendung empfohlen Iterator.remove() Methode.