How to Reverse an Array in Java

Reversing an array is a common task in programming that helps in many algorithmic challenges and real-world applications. In Java, an array is a fixed-size data structure, and reversing it can be done using several different methods. In this blog post, we’ll explore multiple approaches to reverse an array in Java, from using built-in methods to implementing a custom solution.

Method 1: Reversing an Array Using a Loop

One of the most straightforward ways to reverse an array is by using a simple loop to swap elements from the front and the back of the array.

Code Example:

public class ReverseArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        System.out.println("Original Array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        
        // Reversing the array
        int left = 0;
        int right = arr.length - 1;
        
        while (left < right) {
            // Swap the elements
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            
            left++;
            right--;
        }
        
        System.out.println("\nReversed Array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Explanation:

1. We initialize two pointers, left (starting from the first element) and right (starting from the last element).
2. We swap the elements at left and right and move the pointers towards the center (left++ and right--).
3. The loop continues until the pointers meet or cross, ensuring the array is reversed.

Method 2: Using the Collections.reverse() Method

If you’re working with an array of objects (such as Integer[]), you can convert the array to a list and use Java’s Collections.reverse() method to reverse the array.

Code Example:

import java.util.*;

public class ReverseArray {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 3, 4, 5};
        
        System.out.println("Original Array:");
        System.out.println(Arrays.toString(arr));
        
        // Convert the array to a list and reverse it
        List<Integer> list = Arrays.asList(arr);
        Collections.reverse(list);
        
        // Convert the list back to an array
        list.toArray(arr);
        
        System.out.println("Reversed Array:");
        System.out.println(Arrays.toString(arr));
    }
}

Explanation:

1. We convert the array into a list using Arrays.asList().
2. We reverse the list using Collections.reverse().
3. Finally, we convert the list back to an array using toArray().

Note: This method works only for arrays of objects. If you need to reverse an array of primitive types (e.g., int[]), you must use a loop or another method.

Method 3: Using Recursion

For those looking for a more advanced solution, recursion can be used to reverse an array.

Code Example:

public class ReverseArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        System.out.println("Original Array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        
        // Reversing the array using recursion
        reverseArray(arr, 0, arr.length - 1);
        
        System.out.println("\nReversed Array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
    
    public static void reverseArray(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        
        // Swap the elements
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        
        // Recursive call to reverse the inner array
        reverseArray(arr, left + 1, right - 1);
    }
}

Explanation:

1. We define a recursive function reverseArray() that accepts the array and the left and right indices.
2. The base case is when left >= right, meaning the array has been fully reversed.
3. We swap the elements at the left and right indices and recursively call the function for the inner array (incrementing left and decrementing right).

Method 4: Using System.arraycopy()

Another approach is to use System.arraycopy() to copy and reverse the array. However, this method is more suitable when you’re working with additional memory for a new array.

Code Example:

import java.util.Arrays;

public class ReverseArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        System.out.println("Original Array:");
        System.out.println(Arrays.toString(arr));
        
        int[] reversedArr = new int[arr.length];
        
        // Reversing using System.arraycopy
        for (int i = 0; i < arr.length; i++) {
            reversedArr[i] = arr[arr.length - 1 - i];
        }
        
        System.out.println("Reversed Array:");
        System.out.println(Arrays.toString(reversedArr));
    }
}

Explanation:

1. We iterate through the original array and copy the elements into a new array in reverse order.
2. The reversedArr holds the reversed array, and we display it.

Conclusion

Reversing an array in Java can be accomplished in multiple ways, depending on your requirements and the type of array you are working with. From basic loops to using the built-in Collections.reverse() method, each approach has its strengths and use cases. Understanding these methods will help you choose the best one for your specific scenario.

Happy coding!