ArrayList är en del av insamlingsram och finns i paketet java.util. Det ger oss dynamiska arrayer i Java. Det kan dock vara långsammare än vanliga arrayer men kan vara till hjälp i program där mycket manipulation i arrayen behövs. Denna klass finns i java.util paket.
Med introduktionen och uppgraderingarna i java-versioner blir nyare metoder tillgängliga som om vi ser från Java8 att uppfattande lambda-uttryck och strömkoncept inte var tillgängliga innan det, eftersom det introducerades i java version8.
Metoder:
vad är måtten på min datorskärm
- Används för loopar
- Använder medan
- Använder för varje slinga
- Använder Iterator
- Använda Lambda-uttryck (endast efter Java8)
- Använda uppräkningsgränssnitt
Låt oss diskutera dessa metoder som vi genast kan uppfatta. Starta tre metoder är helt enkelt de naiva tillvägagångssätten och metoderna längre fram bär en viss optimering med sig. Kom ihåg här, medan korsande element är mindre tenderar vi i allmänhet att iterera via naivt tillvägagångssätt, bara om storleken på element som ska infogas är stor så använder vi optimala tillvägagångssätt. Låt oss snabbt avsluta var och en av ovanstående tillvägagångssätt.
Metod 1: Används för loop
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 siffror = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iterering med för loop för (int i = 0; i< numbers.size(); i++) // Printing and display the elements in ArrayList System.out.print(numbers.get(i) + ' '); } }> Produktion
1 2 3 4 5 6 7 8>
Metod 2: Använder while loop
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 = ny ArrayList (); // Lägga till element till ArrayList // med add()-metoden al.add(3); al.add(1); al.add(7); al.add(20); al.add(5); // Steg 1: Ställa in och initiera en variabel // enligt syntaxen för while loop // Initialt deklarera och ställa int val = 0; // Steg 2: Villkor // Tills vår räknarvariabel är mindre än storleken på // ArrayList while (al.size()> val) { // Skriver ut elementet som håller över // condition true System.out.println(al .get(val)); // Steg 3: Avsluta villkoret genom att öka // vår räknare i varje iteration val++ ; } } }> Produktion
3 1 7 20 5>
Metod 3: Används för varje slinga
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 siffror = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // För varje slinga för att iterera ArrayList för (Integer i : tal) // Skriva ut elementen i ArrayList System.out.print(i + ' '); } }> Produktion
1 2 3 4 5 6 7 8>
Metod 4: Använder 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 siffror = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Itererar ArrayList med Iterator Iterator it = numbers.iterator(); // Gäller tills det finns ett enda element // kvar i listan medan (it.hasNext()) // Skriv ut elementen i ArrayList System.out.print(it.next() + ' '); } }> Produktion
1 2 3 4 5 6 7 8>
Metod 5: Använda Lambda-uttryck
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 siffror = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Skriva ut nummer med lambda-uttryck // introducerades senare i java8 numbers.forEach(number->System.out.println(number)); } }> Produktion
1 2 3 4 5 6 7 8>
Metod 6: Använda uppräkningsgränssnitt
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 = ny ArrayList (); // Lägga till element till ArrayList al.add(34); al.add(12); al.add(34); al.add(23); al.add(54); // Få ett uppräkningsobjekt Uppräkning e = Collections.enumeration(al); // Till element are there while (e.hasMoreElements()) // Skriv ut element med metoden nextElement() System.out.println(e.nextElement()); } }> Produktion
34 12 34 23 54>
Nu är det ytterligare en tillsats till artikeln då vi är klara med att diskutera alla metoder som kan användas för att iterera över element. Hittills har vi bara gått över ingångselement och inte sett korsningen vad händer om vi leker med element, så överväger vi
Exempel
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 = ny ArrayList (); al.add(10); al.add(20); al.add(30); al.add(1); al.add(2); // Ta bort element mindre än 10 med // Iterator.remove() Iterator itr = al.iterator(); while (itr.hasNext()) { int x = (Heltal)itr.next(); om (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }> Produktion
Modified ArrayList : [10, 20, 30]>
Ta bort föremål under genomkörning: Det rekommenderas inte att använda ArrayList.remove() när man itererar över element. Detta kan leda till ConcurrentModificationException (Hänvisa till detta för ett exempelprogram med detta undantag). Vid iteration över element rekommenderas det att använda Iterator.remove() metod.