Iterating over ArrayLists in Java - GeeksforGeeks

31 Oct, 2021
ArrayList is a part of collection framework and is present in java.util package. It provides us with dynamic arrays in Java. Though, it may be slower than standard arrays but can be helpful in programs where lots of manipulation in the array is needed. This class is found in java.util package.
With the introduction and upgradations in java versions, newer methods are being available as if we do see from Java8 perceptive lambda expressions and streams concepts were not available before it as it been introduced in java version8.
Methods:
Using for loopsUsing whileUsing for-each loopUsing IteratorUsing Lambda expressions (after Java8 only)Using Enumeration interface
Using for loops
Using while
Using for-each loop
Using Iterator
Using Lambda expressions (after Java8 only)
Using Enumeration interface
Let us discuss these methods of which straight away we can perceive starting three methods are simply the naive approaches and further onwards methods carry some optimization with them. Do remember here while traversing elements are lesser we generally tend to iterate via naive approach only else if the size of elements to be inserted is big then we do use optimal approaches. Let us wrap each of the above approaches quickly.
Method 1: Using for loop 
Java
// Java  program to iterate over an ArrayList// Using for loop // Importing all utility classesimport java.util.*; // Main classclass GFG {       // Main driver method     public static void main(String[] args)    {        // Creating and initializing the ArrayList        // Declaring object of integer type        List<Integer> numbers = Arrays.asList(1, 2, 3,                                       4, 5, 6, 7, 8);         // Iterating using for loop        for (int i = 0; i < numbers.size(); i++)                       // Printing and display the elements in ArrayList            System.out.print(numbers.get(i) + " ");           }}
1 2 3 4 5 6 7 8 
Method 2: Using while loop 
Java
// Java Program to Illustrate ArrayList// Using While Loop // Importing required classesimport java.util.ArrayList ; // Main classpublic class GFG {     // Main driver method    public static void main(String[] args)    {         // Creating and initializing the ArrayList        // Declaring object of integer type        ArrayList<Integer> al = new ArrayList<Integer>();         // Adding elements to ArrayList        // using add() method        al.add(3);        al.add(1);        al.add(7);        al.add(20);        al.add(5);         // Step 1: Setting and initializing a variable        // as per syntax of while loop        // Initially declaring and setting        int val = 0;         // Step 2: Condition        // Till our counter variable is lesser than size of        // ArrayList        while (al.size() > val) {             // Printing the element which holds above            // condition true            System.out.println(al.get(val));             // Step 3: Terminating condition by incrementing            // our counter in each iteration            val++ ;        }    }}
3
1
7
20
5
Method 3: Using for each loop 
Java
// Java Program to Iterate over Arraylist// using for Each loop // Importing all utility classesimport java.util.*; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {        // Declaring and initializing ArrayList        List<Integer> numbers            = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);         // For Each Loop for iterating ArrayList        for (Integer i : numbers)             // Printing the elements of ArrayList            System.out.print(i + " ");    }}
1 2 3 4 5 6 7 8 
Method 4: Using Iterator 
Java
// Java program to iterate over an ArrayList// Using Iterator // Importing all utility classesimport java.util.*; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {        // Declaring and initializing ArrayList        List<Integer> numbers            = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);         // Iterating ArrayList using Iterator        Iterator it = numbers.iterator();         // Holds true till there is single element        // remaining in the list        while (it.hasNext())             // Print the elements of ArrayList            System.out.print(it.next() + " ");    }}
1 2 3 4 5 6 7 8 
Method 5: Using Lambda expressions
Java
// Java program to iterate over an arraylist// using Iterator in Java8 with Lambda Expression // Importing all utility classesimport java.util.*; // Main classclass GFG {       // Main driver method    public static void main(String[] args)    {        // Declaring and initializing ArrayList        // Custom input elements        List<Integer> numbers = Arrays.asList(1, 2, 3,                                       4, 5, 6, 7, 8);         // Printing numbers using lambda expressions        // been introduced later in java8        numbers.forEach(number->System.out.println(number));     }}
1
2
3
4
5
6
7
8
Method 6: Using Enumeration interface
Java
// Java Program to Iterate over ArrayList elements// Using Enumeration // Importing required classesimport java.util.ArrayList;import java.util.Collections;import java.util.Enumeration; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an ArrayList        ArrayList<Integer> al = new ArrayList<Integer>();         // Adding elements to ArrayList        al.add(34);        al.add(12);        al.add(34);        al.add(23);        al.add(54);         // Getting an enumeration object        Enumeration<Integer> e            = Collections.enumeration(al);         // Till elements are there        while (e.hasMoreElements())             // Print elements using nextElement() method            System.out.println(e.nextElement());    }}
34
12
34
23
54
Now it is a further additive to the article as we are done with discussing all methods that can be used to iterate over elements. Till now we have traversed over input elements only and have not seen the traversal what if we play with elements, so do we are considering 
Example 
Java
// Java program to demonstrate Working of// Iterator.remove() on Arraylist // Importing utility classesimport java.util.List;import java.util.ArrayList;import java.util.Iterator; // Main classpublic class GFG{    // Main driver method    public static void main(String[] args)    {        // Creating a List with referenceto ArrayList        List<Integer> al = new ArrayList<Integer>();        al.add(10);        al.add(20);        al.add(30);        al.add(1);        al.add(2);         // Remove elements smaller than 10 using        // Iterator.remove()        Iterator itr = al.iterator();        while (itr.hasNext())        {            int x = (Integer)itr.next();            if (x < 10)                itr.remove();        }         System.out.println("Modified ArrayList : "                                           + al);    }}
Modified ArrayList : [10, 20, 30]
Removing Items during Traversal: It is not recommended to use ArrayList.remove() when iterating over elements. This may lead to ConcurrentModificationException (Refer to this for a sample program with this exception). When iterating over elements, it is recommended to use Iterator.remove() method. 
This article is contributed by Nikita Tiwari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
SandeepChaudhary
solankimayank
arorakashish0911
sagartomar9927
anikakapoor
Java-ArrayList
Java-List-Programs
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Interfaces in Java
Singleton Class in Java
LinkedList in Java
Collections in Java
Set in Java
Overriding in Java
Queue Interface In Java
Functional Interfaces in Java
How to add an element to an Array in Java?
Stream In Java