Java Arrays

Learn how to declare, instantiate, and iterate through arrays in Java.

Arrays allow you to store multiple values of the same data type in a single variable. They are one of the most important data structures in Java.

Why Arrays Are Important in Real Java Programs

Arrays are one of the most commonly used data structures in Java. They allow you to store and manage multiple related values efficiently instead of creating many separate variables.

In real-world applications, arrays are used to store lists of users, product prices, exam marks, sensor readings, and API responses. Without arrays, handling such grouped data would become complex and error-prone.

Real-life example:
An e-commerce application stores prices of products in an array, loops through it to calculate the total bill, and applies discounts using array values.

1. What is an Array?

An array groups related values so you can access them using an index. The index always starts from 0.

Try example: 

public class ArrayBasicDemo {
    public static void main(String[] args) {

        String[] cars = {"Volvo", "BMW", "Ford"};

        System.out.println("First car: " + cars[0]); // Output: Volvo
        System.out.println("Total cars: " + cars.length);
    }
}

2. Single-Dimensional Arrays

1D arrays store values in a single list.

Try example: 

public class SingleArrayDemo {
    public static void main(String[] args) {

        int[] numbers = {10, 20, 30, 40};

        System.out.println("Before change: " + numbers[0]);

        numbers[0] = 50;  // Modify value

        System.out.println("After change: " + numbers[0]);
    }
}

Understanding Array Indexing and Length

Every element in a Java array is accessed using an index. Indexes always start from 0 and end at array.length - 1. Trying to access an invalid index causes ArrayIndexOutOfBoundsException.

The length property tells you how many elements an array can hold. It is commonly used in loops to prevent runtime errors.

Real-life example:
If a class has 5 students stored in an array, their roll numbers are accessed from index 0 to 4. Trying to access index 5 means accessing a student who does not exist.

3. Array Operations

A. Looping with Index

Try example: 

public class ArrayLoopDemo {
    public static void main(String[] args) {

        String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

        for (int i = 0; i < cars.length; i++) {
            System.out.println(cars[i]);
        }
    }
}
B. Enhanced For-Each Loop

Try example: 

public class ArrayForEachDemo {
    public static void main(String[] args) {

        String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

        for (String car : cars) {
            System.out.println(car);
        }
    }
}

When to Use for Loop vs for-each Loop

Java provides two common ways to traverse arrays: the traditional for loop and the enhanced for-each loop. Each has its own use case.

  • Use for loop when you need the index value or want to modify array elements.
  • Use for-each loop when you only need to read values and want cleaner code.

Real-life example:
A banking system uses a for loop to update account balances, while a report generator uses a for-each loop to simply display transaction history.

4. Multi-Dimensional Arrays

Multi-dimensional arrays store values in a grid (rows & columns).

Try example: 

public class TwoDArrayDemo {
    public static void main(String[] args) {

        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };

        System.out.println("Value at row 1, col 2: " + matrix[1][2]); // Output: 6
    }
}
Traversing a 2D Array

Try example: 

public class TwoDArrayLoopDemo {
    public static void main(String[] args) {

        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };

        for (int row = 0; row < matrix.length; row++) {
            for (int col = 0; col < matrix[row].length; col++) {
                System.out.print(matrix[row][col] + " ");
            }
            System.out.println();
        }
    }
}

Practical Use of 2D Arrays

Two-dimensional arrays are commonly used to represent tabular data where values are organized in rows and columns. They are also referred to as arrays of arrays.

Typical use cases include:

  • Storing marks of students across multiple subjects
  • Representing matrices in mathematical operations
  • Game boards like chess, sudoku, or tic-tac-toe

Real-life example:
A school management system stores exam scores where each row represents a student and each column represents a subject. A 2D array makes this structure easy to manage and process.

Common Array Mistakes to Avoid

  • Accessing elements outside array bounds
  • Forgetting that array indexes start from 0
  • Assuming arrays can dynamically grow in size
  • Not using length while looping

Always validate indexes and use loop conditions carefully to avoid runtime errors when working with arrays.

Arrays vs Variables – Why Arrays Are Preferred

Using individual variables for storing related values is not scalable. Arrays solve this problem by grouping data under a single name and allowing access through indexes.

When the number of values increases, arrays make the code easier to maintain, simpler to loop through, and less prone to human error. This is why arrays are widely used in real applications.

Real-life example:
Storing monthly electricity bills as separate variables is inefficient. Using an array allows easy calculation of total usage and average consumption.

What to Learn After Arrays

Once you are comfortable with arrays, the next step is learning Java collections such as ArrayList, HashSet, and HashMap, which provide more flexibility.

Arrays have a fixed size, but collections can grow dynamically. Understanding arrays first makes it much easier to learn these advanced concepts.

Arrays are still heavily used in performance-critical systems, low-level logic, and competitive programming, so mastering them is essential for every Java developer.

Previous Try Java Online Compiler Strings