ArrayList is een onderdeel van verzamelkader en is aanwezig in het java.util-pakket. Het biedt ons dynamische arrays in Java. Hoewel het langzamer kan zijn dan standaardarrays, kan het nuttig zijn in programma's waarbij veel manipulatie in de array nodig is. Deze klasse is te vinden in java.util pakket.
Met de introductie en upgrades in Java-versies komen er nieuwere methoden beschikbaar alsof we uit Java8 zien dat opmerkzame lambda-expressies en streams-concepten daarvoor niet beschikbaar waren, aangezien deze in Java-versie8 werden geïntroduceerd.
Methoden:
sorteer een arraylist
- For-lussen gebruiken
- Terwijl gebruiken
- For-elke lus gebruiken
- Iterator gebruiken
- Lambda-expressies gebruiken (alleen na Java8)
- Met behulp van de Enumeratie-interface
Laten we deze methoden bespreken, waarvan we meteen kunnen zien dat de eerste drie methoden eenvoudigweg de naïeve benaderingen zijn, en verderop in de tijd brengen de methoden enige optimalisatie met zich mee. Houd er rekening mee dat, hoewel het doorkruisen van elementen minder is, we over het algemeen de neiging hebben om alleen via een naïeve benadering te itereren, anders gebruiken we optimale benaderingen als de grootte van de in te voegen elementen groot is. Laten we elk van de bovenstaande benaderingen snel afhandelen.
Methode 1: For-lus gebruiken
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 getallen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Itereren met for-lus voor (int i = 0; i< numbers.size(); i++) // Printing and display the elements in ArrayList System.out.print(numbers.get(i) + ' '); } }> Uitvoer
1 2 3 4 5 6 7 8>
Methode 2: While-lus gebruiken
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 = nieuwe ArrayList (); // Elementen toevoegen aan ArrayList // met add() methode al.add(3); al.toevoegen(1); al.add(7); al.toevoegen(20); al.toevoegen(5); // Stap 1: Een variabele instellen en initialiseren // volgens de syntaxis van while-lus // Aanvankelijk declareren en instellen van int val = 0; // Stap 2: Conditie // Totdat onze tellervariabele kleiner is dan de grootte van // ArrayList while (al.size()> val) {// Het element afdrukken dat hierboven geldt // condition true System.out.println(al .get(val)); // Stap 3: Voorwaarde beëindigen door // onze teller in elke iteratie val++ te verhogen; } } }> Uitvoer
3 1 7 20 5>
Methode 3: Gebruik voor elke lus
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 getallen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Voor elke lus voor het herhalen van ArrayList voor (Integer i: getallen) // Afdrukken van de elementen van ArrayList System.out.print(i + ' '); } }> Uitvoer
1 2 3 4 5 6 7 8>
Methode 4: Iterator gebruiken
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 getallen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // ArrayList herhalen met Iterator Iterator it = getallen.iterator(); // Geldt waar totdat er één element overblijft // in de lijst overblijft terwijl (it.hasNext()) // De elementen van ArrayList System.out.print(it.next() + ' '); } }> Uitvoer
1 2 3 4 5 6 7 8>
Methode 5: Lambda-expressies gebruiken
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 getallen = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Getallen afdrukken met behulp van lambda-expressies // later geïntroduceerd in java8 getallen.forEach(number->System.out.println(number)); } }> Uitvoer
1 2 3 4 5 6 7 8>
Methode 6: Met behulp van de Enumeratie-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 = nieuwe ArrayList (); // Elementen toevoegen aan ArrayList al.add(34); al.add(12); al.add(34); al.add(23); al.add(54); // Een opsommingsobject verkrijgen Opsomming e = Collecties.opsomming(al); // Till-elementen zijn aanwezig while (e.hasMoreElements()) // Print elementen met behulp van de nextElement()-methode System.out.println(e.nextElement()); } }> Uitvoer
34 12 34 23 54>
Nu is het een verdere aanvulling op het artikel, aangezien we klaar zijn met het bespreken van alle methoden die kunnen worden gebruikt om elementen te herhalen. Tot nu toe hebben we alleen de invoerelementen doorlopen en hebben we de doorgang niet gezien. Wat als we met elementen spelen, dan overwegen we dat ook
Voorbeeld
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 = nieuwe ArrayList (); al.toevoegen(10); al.toevoegen(20); al.toevoegen(30); al.toevoegen(1); al.toevoegen(2); // Verwijder elementen kleiner dan 10 met // Iterator.remove() Iterator itr = al.iterator(); while (itr.hasNext()) { int x = (geheel getal)itr.next(); als (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }> Uitvoer
Modified ArrayList : [10, 20, 30]>
Items verwijderen tijdens verplaatsing: Het wordt niet aanbevolen om ArrayList.remove() te gebruiken bij het herhalen van elementen. Dit kan leiden tot ConcurrentModificationException (Verwijzen naar dit voor een voorbeeldprogramma met deze uitzondering). Bij iteratie over elementen wordt het aanbevolen om te gebruiken Iterator.verwijder() methode.