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 upgrades in Java versions, newer methods are being available as we do see from Java8 perceptive lambda expressions and streams concepts were not available before it, as it been introduced in java version8.

Methods of Iterating over ArrayLists in Java

Method 1: Using a for loop

Java

import java.util.*;
class 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) + " ");        
    }
}

Output

1 2 3 4 5 6 7 8

Method 2: Using while loop

Java

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<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++ ;
        }
    }
}

Output

Method 3: Using for each loop

Java

import java.util.*;
class 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 + " ");
    }
}

Output

1 2 3 4 5 6 7 8

Method 4: Using Iterator

Java

import java.util.*;

class GFG {

    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() + " ");
    }
}

Output

1 2 3 4 5 6 7 8

Method 5: Using Lambda expressions

Java

import java.util.*;

class GFG {
  
    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));

    }
}

Output

Method 6: Using Enumeration interface

Java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;

class GFG {

    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());
    }
}

Output

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

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

public class GFG
{
    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);
    }
}

Output

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.

Iterating over ArrayLists in Java

Methods of Iterating over ArrayLists in Java

Explore