Reverse An Array In Java Code

Reversing an array is a common operation in programming that involves changing the order of elements such that the first element becomes the last, and the last becomes the first. In this article, you will learn how to effectively reverse arrays in Java using various techniques.

Problem Statement

Often, developers encounter scenarios where data stored in an array needs to be processed or displayed in reverse order. This could be for chronological data, stack-like operations, or simply presenting data from newest to oldest. Without an efficient method, this task can be cumbersome and error-prone.

Example

Consider an array of integers: [1, 2, 3, 4, 5]. After reversing, the array should become: [5, 4, 3, 2, 1].

Background & Knowledge Prerequisites

To understand the solutions presented, readers should have a basic understanding of:

• Java Arrays: How to declare, initialize, and access elements.
• Loops: for loops for iterating through arrays.
• Basic Variable Swapping: How to exchange the values of two variables using a temporary variable.
• Java Collections Framework (for one approach): Specifically, ArrayList and the Collections utility class.

Use Cases or Case Studies

Reversing an array is a fundamental operation applicable in various contexts:

• Displaying Search Results: Showing the most recent results first from a chronologically ordered array.
• Implementing a Stack: While java.util.Stack exists, understanding array reversal can help in custom stack implementations where elements are processed Last-In, First-Out (LIFO).
• String Manipulation: Reversing a character array is a common step in reversing a string or checking for palindromes.
• Game Development: Reversing a sequence of moves or a list of items for specific game logic.
• Algorithm Design: As a sub-step in more complex algorithms, such as sorting or data processing.

Solution Approaches

Here are a few common and effective ways to reverse an array in Java.

Approach 1: Using a Temporary Array

This method involves creating a new array of the same size and populating it with elements from the original array in reverse order.

• Summary: Create a new array and copy elements from the original array into it in reverse.

// Reverse Array Using Temporary Array
import java.util.Arrays; // Required for Arrays.toString()

public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize the original array
        int[] originalArray = {1, 2, 3, 4, 5};
        System.out.println("Original Array: " + Arrays.toString(originalArray));

        // Step 2: Create a new array to store the reversed elements
        int[] reversedArray = new int[originalArray.length];

        // Step 3: Iterate through the original array and copy elements in reverse order
        int j = 0; // Index for the new reversed array
        for (int i = originalArray.length - 1; i >= 0; i--) {
            reversedArray[j] = originalArray[i];
            j++;
        }

        // Step 4: Print the reversed array
        System.out.println("Reversed Array (temp array): " + Arrays.toString(reversedArray));
    }
}

Run

Sample Output:

Original Array: [1, 2, 3, 4, 5]
Reversed Array (temp array): [5, 4, 3, 2, 1]

Stepwise Explanation:

1. An originalArray is defined.
2. A reversedArray of the same size is created to store the result.
3. A for loop iterates from the last element of the originalArray (originalArray.length - 1) down to the first element (0).
4. In each iteration, the element originalArray[i] is placed into reversedArray[j]. The j index increments to fill the reversedArray from the beginning.

Approach 2: Swapping Elements (In-Place Reversal)

This is an efficient method that reverses the array without using any extra space proportional to the input size. It involves swapping elements from opposite ends of the array until the middle is reached.

• Summary: Swap elements from the beginning and end of the array towards the center.

// Reverse Array In-Place (Swapping Elements)
import java.util.Arrays; // Required for Arrays.toString()

public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize the array
        int[] myArray = {10, 20, 30, 40, 50, 60};
        System.out.println("Original Array: " + Arrays.toString(myArray));

        // Step 2: Initialize two pointers, one at the start and one at the end
        int left = 0;
        int right = myArray.length - 1;

        // Step 3: Loop until the pointers meet or cross
        while (left < right) {
            // Step 4: Swap elements at the left and right pointers
            int temp = myArray[left];
            myArray[left] = myArray[right];
            myArray[right] = temp;

            // Step 5: Move pointers towards the center
            left++;
            right--;
        }

        // Step 6: Print the reversed array
        System.out.println("Reversed Array (in-place): " + Arrays.toString(myArray));
    }
}

Run

Sample Output:

Original Array: [10, 20, 30, 40, 50, 60]
Reversed Array (in-place): [60, 50, 40, 30, 20, 10]

Stepwise Explanation:

1. An myArray is defined.
2. Two integer pointers, left (starting at index 0) and right (starting at the last index), are initialized.
3. A while loop continues as long as left is less than right. This ensures elements are swapped only once and the loop stops when the middle of the array is reached.
4. Inside the loop, the values at myArray[left] and myArray[right] are swapped using a temporary variable temp.
5. left is incremented, and right is decremented, moving the pointers closer to the center of the array.

Approach 3: Using Collections.reverse() for ArrayList

Java's Collections utility class provides a convenient reverse() method that works directly on List implementations, such as ArrayList. If you're working with a primitive array, you'll first need to convert it to an ArrayList of wrapper types.

• Summary: Convert the array to an ArrayList, use Collections.reverse(), then convert back if a primitive array is strictly required.

// Reverse Array Using Collections.reverse()
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize the original array (primitive type)
        int[] originalIntArray = {11, 22, 33, 44};
        System.out.println("Original int[]: " + Arrays.toString(originalIntArray));

        // Step 2: Convert primitive int[] to List<Integer>
        List<Integer> list = new ArrayList<>();
        for (int i : originalIntArray) {
            list.add(i);
        }
        System.out.println("Converted List: " + list);

        // Step 3: Use Collections.reverse() to reverse the list
        Collections.reverse(list);

        // Step 4: Print the reversed list
        System.out.println("Reversed List: " + list);

        // Step 5: (Optional) Convert the reversed list back to an int[] if needed
        int[] reversedIntArray = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            reversedIntArray[i] = list.get(i);
        }
        System.out.println("Reversed int[] (from list): " + Arrays.toString(reversedIntArray));

        // --- Example with an Integer array directly (no primitive conversion needed initially) ---
        Integer[] integerArray = {100, 200, 300};
        System.out.println("\\nOriginal Integer[]: " + Arrays.toString(integerArray));
        List<Integer> integerList = Arrays.asList(integerArray); // Convert Integer[] to List directly
        
        // Note: Arrays.asList returns a fixed-size list. If you need to modify its structure (add/remove),
        // wrap it in a new ArrayList: List<Integer> modifiableList = new ArrayList<>(Arrays.asList(integerArray));

        Collections.reverse(integerList);
        System.out.println("Reversed Integer List: " + integerList);
        System.out.println("Original (now reversed) Integer[]: " + Arrays.toString(integerArray)); // original array is also reversed
    }
}

Run

Sample Output:

Original int[]: [11, 22, 33, 44]
Converted List: [11, 22, 33, 44]
Reversed List: [44, 33, 22, 11]
Reversed int[] (from list): [44, 33, 22, 11]

Original Integer[]: [100, 200, 300]
Reversed Integer List: [300, 200, 100]
Original (now reversed) Integer[]: [300, 200, 100]

Stepwise Explanation:

1. A primitive int[] is first iterated over to manually add its elements into a new ArrayList. (For Integer[] arrays, Arrays.asList() can be used directly, though it creates a fixed-size list).
2. Collections.reverse(list) is called, which efficiently reverses the order of elements within the ArrayList in place.
3. (Optional) If the final output must be a primitive int[] again, a new int[] is created, and elements are copied back from the reversed ArrayList.
4. The second example shows direct conversion of Integer[] to List using Arrays.asList(), and demonstrates that Collections.reverse() modifies the underlying array directly when Arrays.asList() is used.

Conclusion

Reversing an array in Java can be achieved through several methods, each with its own advantages. The in-place swapping method (Approach 2) is generally preferred for its efficiency in terms of space complexity, as it does not require additional memory. For convenience when working with List objects, Collections.reverse() (Approach 3) offers a concise solution. When memory is not a concern or if immutability of the original array is desired, creating a temporary array (Approach 1) is a straightforward option.

Summary

• Temporary Array: Creates a new array, preserving the original. Good for when the original array must remain unchanged.
• In-Place Swapping: Reverses the array without using extra memory (O(1) space complexity). Highly efficient for large arrays.
• Collections.reverse(): A convenient method for List implementations (like ArrayList). Requires converting primitive arrays to List first.