ArrayList jest częścią ramy kolekcji i jest obecny w pakiecie java.util. Zapewnia nam dynamiczne tablice w Javie. Chociaż może być wolniejszy niż standardowe tablice, ale może być pomocny w programach, w których potrzebne jest wiele manipulacji tablicą. Ta klasa znajduje się w java.util pakiet.
Wraz z wprowadzeniem i aktualizacjami wersji Java dostępne są nowsze metody, tak jakbyśmy widzieli w Javie 8. Percepcyjne wyrażenia lambda i koncepcje strumieni nie były wcześniej dostępne, tak jak zostały wprowadzone w wersji Java 8.
Metody:
zmienna basha
- Używanie pętli for
- Używanie podczas
- Używanie pętli for-each
- Korzystanie z Iteratora
- Używanie wyrażeń Lambda (tylko po Java8)
- Korzystanie z interfejsu wyliczeniowego
Omówmy te metody, z których od razu możemy dostrzec, że początkowe trzy metody są po prostu podejściami naiwnymi, a dalsze metody niosą ze sobą pewną optymalizację. Pamiętaj, że chociaż elementów przechodzenia jest mniej, zazwyczaj mamy tendencję do iteracji metodą naiwną, tylko jeśli rozmiar wstawianych elementów jest duży, wówczas stosujemy podejścia optymalne. Zakończmy szybko każde z powyższych podejść.
Metoda 1: Używanie pętli for
Jawa
// 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 liczby = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iteracja przy użyciu pętli for (int i = 0; i< numbers.size(); i++) // Printing and display the elements in ArrayList System.out.print(numbers.get(i) + ' '); } }> Wyjście
1 2 3 4 5 6 7 8>
Metoda 2: Użycie pętli while
Jawa // 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 = nowa lista tablic (); // Dodawanie elementów do ArrayList // przy użyciu metody add() al.add(3); al.add(1); al.add(7); al.add(20); al.add(5); // Krok 1: Ustawienie i inicjalizacja zmiennej // zgodnie ze składnią pętli while // Wstępna deklaracja i ustawienie int val = 0; // Krok 2: Warunek // Dopóki nasza zmienna licznika nie będzie mniejsza niż rozmiar // ArrayList while (al.size()> val) { // Drukowanie elementu, który spełnia powyższe // warunek true System.out.println(al .get(val)); // Krok 3: Zakończenie warunku poprzez zwiększenie // naszego licznika w każdej iteracji val++ ; } } }> Wyjście
3 1 7 20 5>
Metoda 3: Używanie dla każdej pętli
Jawa // 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 liczby = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // For Every Loop do iteracji ArrayList for (Integer i : liczb) // Drukowanie elementów ArrayList System.out.print(i + ' '); } }> Wyjście
1 2 3 4 5 6 7 8>
Metoda 4: Korzystanie z Iteratora
Jawa
// 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 liczby = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iteracja ArrayList przy użyciu Iteratora Iterator it = Numbers.iterator(); // Dzieje się tak, dopóki na liście // nie pozostanie pojedynczy element while (it.hasNext()) // Wypisz elementy ArrayList System.out.print(it.next() + ' '); } }> Wyjście
1 2 3 4 5 6 7 8>
Metoda 5: Korzystanie z wyrażeń Lambda
Jawa // 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 liczby = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Drukowanie liczb przy użyciu wyrażeń lambda // wprowadzono później w java8 numbers.forEach(number->System.out.println(number)); } }> Wyjście
1 2 3 4 5 6 7 8>
Metoda 6: Korzystanie z interfejsu wyliczeniowego
Jawa // 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 = nowa lista tablic (); // Dodawanie elementów do ArrayList al.add(34); al.add(12); al.add(34); al.add(23); al.add(54); // Pobieranie obiektu wyliczeniowego Enumeration e = Kolekcje.wyliczenie(al); // Dopóki nie ma elementów while (e.hasMoreElements()) // Wydrukuj elementy przy użyciu metody nextElement() System.out.println(e.nextElement()); } }> Wyjście
34 12 34 23 54>
Teraz jest to kolejny dodatek do artykułu, ponieważ mamy już za sobą omawianie wszystkich metod, których można użyć do iteracji po elementach. Do tej pory przemierzaliśmy tylko elementy wejściowe i nie widzieliśmy tego przechodzenia, co jeśli będziemy bawić się elementami, więc czy rozważamy
Przykład
Jawa // 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 = nowa lista tablic (); al.add(10); al.add(20); al.add(30); al.add(1); al.add(2); // Usuń elementy mniejsze niż 10 za pomocą // Iterator.remove() Iterator itr = al.iterator(); while (itr.hasNext()) { int x = (liczba całkowita)itr.next(); jeśli (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }> Wyjście
Modified ArrayList : [10, 20, 30]>
Usuwanie przedmiotów podczas przemierzania: Nie zaleca się używania metody ArrayList.remove() podczas iteracji po elementach. Może to prowadzić do Wyjątek ConcurrentModificationException (Odnosić się do Ten dla przykładowego programu z tym wyjątkiem). Podczas iteracji po elementach zaleca się użycie Iterator.usuń() metoda.