2026-04-186 min read

Example 3: Iterating Over an Array of Objects (Java)

Learn Example 3: Iterating Over an Array of Objects (Java) step by step with clear examples and exercises.

Why This Matters

Iterating over arrays of objects is essential in Java as it allows us to handle complex data structures and real-world programming scenarios efficiently. By understanding this concept, we can work with collections of multiple variables that store references to objects of the same class.

Prerequisites

To fully grasp this lesson, you should be familiar with:

Basic Java syntax and structure
Classes and objects
Arrays in Java
Loop control statements (for loops)
Understanding object-oriented programming concepts such as inheritance and interfaces
Understanding the concept of polymorphism, which will help when dealing with arrays containing objects of different classes or interfaces
Familiarity with constructors, getters, and setters in Java

Core Concept

An array of objects is a collection of multiple variables that store references to objects of the same class. In Java, arrays can be iterated using for loops or enhanced for-each loops.

Creating an Array of Objects

To create an array of objects, follow these steps:

Define a class for the objects you want to store in the array.
Instantiate objects of that class and assign them to elements of the array.
Declare the array with the appropriate data type (the class name).
Initialize the array with a specific size using the new keyword.

Here's an example:

public class Student {
String name;
int age;

public Student(String name, int age) {
this.name = name;
this.age = age;
}
}

public class Main {
public static void main(String[] args) {
// Define the array size and create an array of Students
int numStudents = 3;
Student[] students = new Student[numStudents];

// Instantiate objects for each student and add them to the array
students[0] = new Student("Alice", 25);
students[1] = new Student("Bob", 24);
students[2] = new Student("Charlie", 23);
}
}

Iterating Over an Array of Objects

To iterate over an array of objects, use either a traditional for loop or the enhanced for-each loop.

Traditional For Loop

for (int i = 0; i < students.length; i++) {
// Access each student object and print its details
Student currentStudent = students[i];
System.out.println("Name: " + currentStudent.name + ", Age: " + currentStudent.age);
}

Enhanced For-Each Loop

for (Student student : students) {
// Access each student object and print its details
System.out.println("Name: " + student.name + ", Age: " + student.age);
}

Iterating Over an Array of Heterogeneous Objects

If you have an array containing objects of different classes, you can use a traditional for loop and cast each element accordingly. Here's an example using a superclass Entity:

public class Entity {
String name;

public Entity(String name) {
this.name = name;
}
}

public class Student extends Entity {
int age;

public Student(String name, int age) {
super(name);
this.age = age;
}
}

public class Employee extends Entity {
double salary;

public Employee(String name, double salary) {
super(name);
this.salary = salary;
}
}

public class Main {
public static void main(String[] args) {
// Define and initialize an array of heterogeneous objects
Entity[] entities = new Entity[3];
entities[0] = new Student("Alice", 25);
entities[1] = new Employee("Bob", 6000);
entities[2] = new Student("Charlie", 23);

// Iterate over the array and print each object's details
for (Entity entity : entities) {
if (entity instanceof Student) {
Student student = (Student) entity;
System.out.println("Name: " + student.name + ", Age: " + student.age);
} else if (entity instanceof Employee) {
Employee employee = (Employee) entity;
System.out.println("Name: " + employee.name + ", Salary: " + employee.salary);
}
}
}
}

Worked Example

Let's consider a more practical example, where we have an array of Employee objects and need to calculate the total salary for all employees.

First, let's define the Employee class:

public class Employee extends Entity {
double salary;

public Employee(String name, double salary) {
super(name);
this.salary = salary;
}
}

Next, we'll create an array of Employee objects and calculate the total salary:

public class Main {
public static void main(String[] args) {
// Define the number of employees and create an array of Employees
int numEmployees = 5;
Employee[] employees = new Employee[numEmployees];

// Instantiate objects for each employee and add them to the array
employees[0] = new Employee("Alice", 5000);
employees[1] = new Employee("Bob", 6000);
employees[2] = new Employee("Charlie", 7000);
employees[3] = new Employee("Dave", 8000);
employees[4] = new Employee("Eve", 9000);

// Initialize total salary to zero
double totalSalary = 0;

// Iterate over the array and calculate the total salary
for (Employee employee : employees) {
totalSalary += employee.salary;
}

// Print the total salary
System.out.println("Total Salary: " + totalSalary);
}
}

When you run this code, it will output: Total Salary: 39000.

Common Mistakes

Forgetting to initialize the array: Always make sure to initialize your arrays with the appropriate size using the new keyword.
Accessing invalid array indices: Ensure that the index you're accessing is within the bounds of the array (i.e., between 0 and array.length - 1).
Not defining a class for objects in the array: If you want to store objects in an array, make sure to define a class for those objects first.
Trying to use primitive types instead of objects in the array: Primitive types like int, double, and char cannot be stored directly in an object array; create a wrapper class if needed.
Not using the enhanced for-each loop correctly: Make sure to declare the iterator variable with the same data type as the elements in the array.
Casting errors when iterating over arrays of heterogeneous objects: Ensure that you properly cast each element to its corresponding class before accessing its properties or methods.
Not defining appropriate constructors and getters/setters for your classes: Make sure your classes have proper constructors, getters, and setters to facilitate easy object creation and manipulation.

Practice Questions

Given an array of Book objects, write a Java program that calculates the total number of pages for all books. (Assume each book has a pages property.)
Write a Java program that sorts an array of Employee objects by their salaries using the enhanced for-each loop and the Arrays.sort() method.
Write a Java program that finds the average age of employees in an array of Employee objects.
Given an array of Rectangle objects, write a Java program that calculates the total area of all rectangles. (Assume each rectangle has width and height properties.)
Write a Java program that finds the oldest employee in an array of Employee objects.
Write a Java program that sorts an array of heterogeneous objects by their names using a traditional for loop and casting.
Given an array of Shape objects, write a Java program that calculates the total perimeter of all shapes. (Assume each shape has a perimeter() method.)

FAQ

Can I iterate over an array of primitive types using a for-each loop? No, you cannot use a for-each loop to iterate over arrays of primitive types like int, double, or char. Use a traditional for loop instead.
What happens if I try to access an invalid index in an array? Accessing an invalid index in Java will result in a ArrayIndexOutOfBoundsException.
Can I store objects of different classes in the same array? Yes, you can store objects of different classes in the same array as long as they are related by inheritance or implement the same interface.
How do I define a custom class for my array elements? To define a custom class for your array elements, follow these steps:

Create a new class with appropriate properties and constructors.
Use the defined class as the data type when declaring and initializing the array.

What is the difference between a traditional for loop and an enhanced for-each loop? A traditional for loop uses an index variable to iterate over each element in an array, while an enhanced for-each loop directly iterates over the elements without needing an index. The enhanced for-each loop is preferred when you only need to access or modify the elements themselves.
How can I avoid casting errors when iterating over arrays of heterogeneous objects? To avoid casting errors, consider using a common superclass or interface for all objects in the array. This way, you can cast each element to its specific class safely.
What is the best practice for handling exceptions when accessing invalid indices in an array? The best practice is to handle ArrayIndexOutOfBoundsException by validating the index before using it or providing a default value when an out-of-bounds error occurs.