Iterating over ArrayLists in Java
Last Updated :
04 Jun, 2024
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 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 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<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) + " ");
}
}
Method 2: Using while loop
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<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++ ;
}
}
}
Method 3: Using for each 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 + " ");
}
}
Method 4: Using Iterator
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() + " ");
}
}
Method 5: Using Lambda expressions
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));
}
}
Method 6: Using Enumeration 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<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());
}
}
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);
}
}
OutputModified 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.
Similar Reads
Internal Working of ArrayList in Java ArrayList is a resizable array implementation in Java. ArrayList grows dynamically and ensures that there is always a space to add elements. The backing data structure of ArrayList is an array of Object classes. ArrayList class in Java has 3 constructors. It has its own version of readObject and wri
10 min read
ArrayList of ArrayList in Java We have discussed that an array of ArrayList is not possible without warning. A better idea is to use ArrayList of ArrayList. Java // Java code to demonstrate the concept of // array of ArrayList import java.util.*; public class Arraylist { public static void main(String[] args) { int n = 3; // Here
1 min read
Initialize an ArrayList in Java ArrayList is a part of the collection framework and is present in java.util package. It provides us 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.ArrayList inherits the AbstractList class and imp
4 min read
ArrayList in Java Java ArrayList is a part of the collections framework and it is a class of java.util package. It provides us with dynamic-sized arrays in Java. The main advantage of ArrayList is that, unlike normal arrays, we don't need to mention the size when creating ArrayList. It automatically adjusts its capac
9 min read
Join two ArrayLists in Java Given two ArrayLists in Java, the task is to join these ArrayLists. Examples:Input: ArrayList1: [Geeks, For, ForGeeks] , ArrayList2: [GeeksForGeeks, A computer portal] Output: [Geeks, For, ForGeeks, GeeksForGeeks, A computer portal] Input: ArrayList1: [G, e, e, k, s] , ArrayList2: [F, o, r, G, e, e,
1 min read