Open In App

Iterating over ArrayLists in Java

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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:

  1. Using for loops
  2. Using while
  3. Using for-each loop
  4. Using Iterator
  5. Using Lambda expressions (after Java8 only)
  6. 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 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<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 2: Using while loop 

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<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

3
1
7
20
5

Method 3: Using for each loop 

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<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

1 2 3 4 5 6 7 8 

Method 4: Using Iterator 

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<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

1 2 3 4 5 6 7 8 

Method 5: Using Lambda expressions

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<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

1
2
3
4
5
6
7
8

Method 6: Using Enumeration interface

Java





Output

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 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<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. 



Last Updated : 31 Oct, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads