ArrayList er en del af indsamlingsramme og er til stede i java.util-pakken. Det giver os dynamiske arrays i Java. Det kan dog være langsommere end standard arrays, men det kan være nyttigt i programmer, hvor der er behov for masser af manipulation i arrayet. Denne klasse findes i java.util pakke.
Med introduktionen og opgraderingerne i java-versioner bliver nyere metoder tilgængelige, som om vi ser fra Java8, at perceptive lambda-udtryk og streams-koncepter ikke var tilgængelige før det, da det blev introduceret i java version8.
Metoder:
java få aktuel tid
- Bruges til sløjfer
- Bruger mens
- Brug for hver sløjfe
- Brug af Iterator
- Brug af Lambda-udtryk (kun efter Java8)
- Brug af enumeration interface
Lad os diskutere disse metoder, hvoraf vi med det samme kan opfatte startende tre metoder er simpelthen de naive tilgange og videre fremadgående metoder bærer en vis optimering med sig. Husk her, mens krydsende elementer er mindre, har vi generelt en tendens til at iterere via naiv tilgang, ellers hvis størrelsen af elementer, der skal indsættes, er stor, så bruger vi optimale tilgange. Lad os ombryde hver af ovenstående tilgange hurtigt.
Metode 1: Bruges til 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 tal = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iteration ved hjælp af for loop for (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>
Metode 2: Bruger while-løkke
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 (); // Tilføjelse af elementer til ArrayList // ved hjælp af add() metoden al.add(3); al.add(1); al.add(7); al.add(20); al.add(5); // Trin 1: Indstilling og initialisering af en variabel // i henhold til syntaks for while loop // Indledningsvis erklære og indstille int val = 0; // Trin 2: Betingelse // Indtil vores tællervariabel er mindre end størrelsen af // ArrayList while (al.size()> val) { // Udskriver elementet, der holder over // condition true System.out.println(al .get(val)); // Trin 3: Afsluttende betingelse ved at øge // vores tæller i hver iteration val++ ; } } }> Produktion
3 1 7 20 5>
Metode 3: Bruges til hver sløjfe
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 tal = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // For hver sløjfe til iteration af ArrayList for (Integer i : tal) // Udskrivning af elementerne i ArrayList System.out.print(i + ' '); } }> Produktion
1 2 3 4 5 6 7 8>
Metode 4: Brug af 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 tal = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iterating ArrayList ved hjælp af Iterator Iterator it = numbers.iterator(); // Gælder indtil der er et enkelt element // tilbage på listen mens (it.hasNext()) // Udskriv elementerne i ArrayList System.out.print(it.next() + ' '); } }> Produktion
1 2 3 4 5 6 7 8>
Metode 5: Brug af Lambda-udtryk
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 tal = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Udskrivning af tal ved hjælp af lambda-udtryk // blevet introduceret senere i java8 numbers.forEach(number->System.out.println(number)); } }> Produktion
1 2 3 4 5 6 7 8>
Metode 6: Brug af enumeration interface
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 (); // Tilføjelse af elementer til ArrayList al.add(34); al.add(12); al.tilføj(34); al.tilføj(23); al.add(54); // Hentning af et optællingsobjekt Optælling e = Collections.enumeration(al); // Till-elementer er der while (e.hasMoreElements()) // Udskriv elementer ved hjælp af nextElement()-metoden System.out.println(e.nextElement()); } }> Produktion
34 12 34 23 54>
Nu er det et yderligere additiv til artiklen, da vi er færdige med at diskutere alle metoder, der kan bruges til at iterere over elementer. Indtil nu har vi kun krydset input-elementer og ikke set gennemgangen, hvad hvis vi leger med elementer, så overvejer vi
Eksempel
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); // Fjern elementer mindre end 10 ved hjælp af // Iterator.remove() Iterator itr = al.iterator(); while (itr.hasNext()) { int x = (Heltal)itr.next(); hvis (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }> Produktion
Modified ArrayList : [10, 20, 30]>
Fjernelse af genstande under gennemkørsel: Det anbefales ikke at bruge ArrayList.remove() ved iteration over elementer. Dette kan føre til ConcurrentModificationException (Henvise til det her for et eksempelprogram med denne undtagelse). Ved iteration over elementer anbefales det at bruge Iterator.remove() metode.