Updated April 11, 2023

## Introduction to 2D Array Sorting in Java

The following article provides an outline for 2D Array Sorting in Java. An array of arrays can be a two-dimensional array. The matrices that make up the 2D array represent a collection of rows and columns. Because the elements of 2D arrays can get accessed at random, we can access the individual cells in a 2D array using their indexes, just like we can with one-dimensional arrays.

In a 2D array, a cell has two indexes one is its row number, and the other is its column number. Sorting is a technique for arranging elements in a 2D array in a specific order. The 2D array can be in either ascending or descending order. Let’s see how to sort different ways the 2D array in Java in ascending and descending order.

### Examples of 2D Array Sorting in Java

Different examples are as below:

#### Example #1

Example for 2D array sorting in Java to sort all elements of a 2D Array.

**Code:**

```
package jex;
import java.util.*;
public class demo {
// using bubble sort to sort 2D array
// sort 2D array same as it is in a 1D array of size n * m
public static void sort(int arr[][]) {
int i, j, temp;
int n=arr.length;
int m=arr[0].length;
for (i = 0; i < n * m - 1; ++i) {
for (j = 0; j < n * m - 1 - i; ++j) {
if (arr[j / m][j % m] > arr[(j + 1) / m][(j + 1) % m]) {
temp = arr[(j + 1) / m][(j + 1) % m];
arr[(j + 1) / m][(j + 1) % m] = arr[j / m][j % m];
arr[j / m][j % m] = temp;
}
}
}
}
public static void print(int arr[][]) {
int i, j;
int n=arr.length;
int m=arr[0].length;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int[][] arr={ { 5, 12, 17, 12, 23},
{ 1, 2, 4, 6, 8},
{21, 14, 7, 19, 27},
{ 3, 18, 9, 15, 25}
};
System.out.println("Array Before Sorting is : ");
print(arr);
sort(arr);
System.out.println("Array After Sorting is : ");
print(arr);
}
}
```

**Output:**

As in the above program, the sort() method is useful to iterate each element of a 2D array, and when the current element is greater than the next element, then swap the numbers. Finally, the print method displays all the elements of the 2D array. In the main function, the 2D array is created and printed after and before calling the sort() function, as shown in the above output.

#### Example #2

Example for 2D array sorting in Java to sort all elements of a 2D array by column-wise.

**Code:**

```
package jex;
import java.util.*;
public class demo {
public static void sort(int arr[][]) {
int i, j,k, temp;
int n=arr.length;
int m=arr[0].length;
for (k = 0; k < m; ++k) {
for (i = 0; i < n; ++i) {
for (j = 0; j < n - 1 - i; ++j) {
if (arr[j][k] > arr[j + 1][k]) {
temp = arr[j + 1][k];
arr[j + 1][k] = arr[j][k];
arr[j][k] = temp;
}
}
}
}
}
public static void print(int arr[][]) {
int i, j;
int n=arr.length;
int m=arr[0].length;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int[][] arr={ { 5, 12, 17, 12, 23},
{ 1, 2, 4, 6, 8},
{21, 14, 7, 19, 27},
{ 3, 18, 9, 15, 25}
};
System.out.println("Array Before Sorting is : ");
print(arr);
sort(arr);
System.out.println("Array After Sorting is : ");
print(arr);
}
}
```

**Output:**

As in the above rewrite program, the sort() method is useful to iterate each element of a 2D array and sort the array column-wise. Finally, the print method displays all the elements of the 2D array. In the main function, the 2D array is created and printed after and before calling the sort() function, as shown in the above output.

#### Example #3

To sort all elements of a 2D array by row-wise.

**Code:**

```
package jex;
import java.util.*;
public class demo {
// using bubble sort to sort 2D array
// sort 2D array same as it is in a 1D array of size n * m
public static void sort(int arr[][]) {
int i, j,k, temp;
int n=arr.length;
int m=arr[0].length;
for(k=0;k<n;++k){
// applying bubble sort on kth row
for(i=0;i<m;++i){
for(j=0;j<m-1-i;++j){
if(arr[k][j]>arr[k][j+1]){
temp = arr[k][j+1];
arr[k][j+1] = arr[k][j];
arr[k][j] = temp;
}
}
}
}
}
public static void print(int arr[][]) {
int i, j;
int n=arr.length;
int m=arr[0].length;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int[][] arr={ { 5, 12, 17, 12, 23},
{ 1, 2, 4, 6, 8},
{21, 14, 7, 19, 27},
{ 3, 18, 9, 15, 25}
};
System.out.println("Array Before Sorting is : ");
print(arr);
sort(arr);
System.out.println("Array After Sorting is : ");
print(arr);
}
}
```

**Output:**

As in the above rewrite program, the sort() method is useful to iterate each element of a 2D array and sort the array row-wise. Finally, the print method displays all the elements of the 2D array. In the main function, the 2D array is created and printed after and before calling the sort() function, as shown in the above output.

### Conclusion

Sorting is a technique for arranging elements in a 2D array in a specific order. For example, in a 2D array, a cell has two indexes: its row number and its column number.

### Recommended Articles

This is a guide to 2D Array Sorting in Java. Here we discuss the introduction and examples of 2D array sorting in Java, respectively. You may also have a look at the following articles to learn more –