Reverse Row of a 2D Array in Java

Manipulating two-dimensional arrays is a common task in Java programming, often encountered in various applications such as image processing, game development, and data analysis. One specific operation is reversing the rows of a 2D array. Reversing the rows means that the order of elements within each row of the 2D array is reversed. This blog post will provide a detailed guide on how to reverse the rows of a 2D array in Java, covering different approaches, common practices, and best practices.

Table of Contents#

  1. Prerequisites
  2. Understanding 2D Arrays in Java
  3. Approach 1: Using Nested Loops
  4. Approach 2: Using Java Collections
  5. Common Practices
  6. Best Practices
  7. Example Usage
  8. Conclusion
  9. References

Prerequisites#

To follow along with this blog post, you should have a basic understanding of Java programming, including variables, data types, loops, and arrays. Familiarity with Java's Collections framework will also be helpful for the second approach.

Understanding 2D Arrays in Java#

A two-dimensional array in Java is essentially an array of arrays. It can be visualized as a table with rows and columns. Each element in the 2D array is accessed using two indices: the first index represents the row number, and the second index represents the column number. Here is an example of declaring and initializing a 2D array in Java:

int[][] twoDArray = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

In this example, twoDArray is a 2D array with 3 rows and 3 columns.

Approach 1: Using Nested Loops#

The most straightforward way to reverse the rows of a 2D array is by using nested loops. The outer loop iterates over each row of the 2D array, and the inner loop reverses the elements within each row. Here is the Java code to implement this approach:

public class Reverse2DArrayRows {
    public static void reverseRows(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            int start = 0;
            int end = arr[i].length - 1;
            while (start < end) {
                int temp = arr[i][start];
                arr[i][start] = arr[i][end];
                arr[i][end] = temp;
                start++;
                end--;
            }
        }
    }
 
    public static void main(String[] args) {
        int[][] twoDArray = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
 
        System.out.println("Original 2D array:");
        print2DArray(twoDArray);
 
        reverseRows(twoDArray);
 
        System.out.println("2D array after reversing rows:");
        print2DArray(twoDArray);
    }
 
    public static void print2DArray(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

In this code, the reverseRows method takes a 2D array as input and reverses the elements within each row. The main method demonstrates how to use the reverseRows method by creating a 2D array, printing the original array, reversing the rows, and then printing the modified array.

Approach 2: Using Java Collections#

Another approach to reversing the rows of a 2D array is by using Java's Collections framework. First, convert each row of the 2D array into a List, reverse the List, and then convert it back to an array. Here is the Java code to implement this approach:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class Reverse2DArrayRowsUsingCollections {
    public static void reverseRows(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            List<Integer> rowList = new ArrayList<>();
            for (int j = 0; j < arr[i].length; j++) {
                rowList.add(arr[i][j]);
            }
            Collections.reverse(rowList);
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = rowList.get(j);
            }
        }
    }
 
    public static void main(String[] args) {
        int[][] twoDArray = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
 
        System.out.println("Original 2D array:");
        print2DArray(twoDArray);
 
        reverseRows(twoDArray);
 
        System.out.println("2D array after reversing rows:");
        print2DArray(twoDArray);
    }
 
    public static void print2DArray(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

In this code, the reverseRows method converts each row of the 2D array into a List, reverses the List using Collections.reverse, and then copies the reversed elements back to the original 2D array.

Common Practices#

  • Input Validation: Before reversing the rows of a 2D array, it is a good practice to validate the input array. Check if the array is null or if it has zero rows or columns.
  • Avoiding Modifying the Original Array: If you don't want to modify the original 2D array, create a copy of the array before reversing the rows.

Best Practices#

  • Efficiency: The nested loop approach is generally more efficient than the Collections approach because it operates directly on the array without the overhead of converting to and from List objects.
  • Code Readability: Use meaningful variable names and add comments to your code to make it more readable and maintainable.

Example Usage#

Here is an example of how you can use the reverseRows method in a real-world scenario:

import java.util.Random;
 
public class ExampleUsage {
    public static void main(String[] args) {
        int[][] random2DArray = generateRandom2DArray(5, 5);
 
        System.out.println("Original random 2D array:");
        print2DArray(random2DArray);
 
        Reverse2DArrayRows.reverseRows(random2DArray);
 
        System.out.println("Random 2D array after reversing rows:");
        print2DArray(random2DArray);
    }
 
    public static int[][] generateRandom2DArray(int rows, int columns) {
        int[][] arr = new int[rows][columns];
        Random random = new Random();
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                arr[i][j] = random.nextInt(100);
            }
        }
        return arr;
    }
 
    public static void print2DArray(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

In this example, the generateRandom2DArray method creates a 2D array with random elements, and the Reverse2DArrayRows.reverseRows method is used to reverse the rows of the array.

Conclusion#

Reversing the rows of a 2D array in Java can be achieved using different approaches, such as nested loops or the Collections framework. The nested loop approach is more efficient, while the Collections approach provides a more convenient way to reverse the rows. By following common practices and best practices, you can write clean, efficient, and readable code to manipulate 2D arrays in Java.

References#

2026-05