java Arrays.sort 2d array

Welcome Java 8:

Arrays.sort(myArr, (a, b) -> Double.compare(a[0], b[0]));

The simplest way:

Arrays.sort(myArr, (a, b) -> a[0] - b[0]);

Decreasing/increasing order for an integer array of 2 dimension you can use:

Arrays.sort(contests, (a, b) -> Integer.compare(b[0],a[0])); //decreasing order
    
Arrays.sort(contests, (a, b) -> Integer.compare(a[0],b[0]); //increasing order

Although this is an old thread, here are two examples for solving the problem in Java8.

sorting by the first column ([][0]):

double[][] myArr = new double[mySize][2];
// ...
java.util.Arrays.sort(myArr, java.util.Comparator.comparingDouble(a -> a[0]));

sorting by the first two columns ([][0], [][1]):

double[][] myArr = new double[mySize][2];
// ...
java.util.Arrays.sort(myArr, java.util.Comparator.<double[]>comparingDouble(a -> a[0]).thenComparingDouble(a -> a[1]));

You need to implement a Comparator<Double[]> like so:

public static void main(String[] args) throws IOException {
    final Double[][] doubles = new Double[][]{{5.0, 4.0}, {1.0, 1.0}, {4.0, 6.0}};
    final Comparator<Double[]> arrayComparator = new Comparator<Double[]>() {
        @Override
        public int compare(Double[] o1, Double[] o2) {
            return o1[0].compareTo(o2[0]);
        }
    };
    Arrays.sort(doubles, arrayComparator);
    for (final Double[] arr : doubles) {
        System.out.println(Arrays.toString(arr));
    }
}

Output:

[1.0, 1.0]
[4.0, 6.0]
[5.0, 4.0]

It is really simple, there are just some syntax you have to keep in mind.

Arrays.sort(contests, (a, b) ->
Integer.compare(a[0],b[0]));//increasing order     ---1

Arrays.sort(contests, (b, a) ->
Integer.compare(b[0],a[0]));//increasing order     ---2

Arrays.sort(contests, (a, b) ->
Integer.compare(b[0],a[0]));//decreasing order     ---3

Arrays.sort(contests, (b, a) ->
Integer.compare(a[0],b[0]));//decreasing order     ---4

If you notice carefully, then it's the change in the order of 'a' and 'b' that affects the result. For line 1, the set is of (a,b) and Integer.compare(a[0],b[0]), so it is increasing order. Now if we change the order of a and b in any one of them, suppose the set of (a,b) and Integer.compare(b[0],a[0]) as in line 3, we get decreasing order.

Simplified Java 8

IntelliJ suggests to simplify the top answer to the:

Arrays.sort(queries, Comparator.comparingDouble(a -> a[0]));

To sort in descending order you can flip the two parameters

int[][] array= {
    {1, 5},
    {13, 1},
    {12, 100},
    {12, 85} 
};
Arrays.sort(array, (b, a) -> Integer.compare(a[0], b[0]));

Output:

13, 5
12, 100
12, 85
1, 5

This one is straight forward and safe way:
Assume:

int[][]arr=new int[3][4];
Arrays.sort(arr, (a,b)->Integer.Compare(a[0],b[0]));

much simpler code:

import java.util.Arrays; int[][] array = new int[][];

Arrays.sort(array, ( a, b) -> a[1] - b[1]);

import java.util.*;

public class Arrays2
{
    public static void main(String[] args)
    {
        int small, row = 0, col = 0, z;
        int[][] array = new int[5][5];

        Random rand = new Random();
        for(int i = 0; i < array.length; i++)
        {
            for(int j = 0; j < array[i].length; j++)
            {
                array[i][j] = rand.nextInt(100);
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println("\n");


        for(int k = 0; k < array.length; k++)
        {
            for(int p = 0; p < array[k].length; p++)
            {
                small = array[k][p];
                for(int i = k; i < array.length; i++)
                {
                    if(i == k)
                        z = p + 1;
                    else
                        z = 0;
                    for(;z < array[i].length; z++)
                    {
                        if(array[i][z] <= small)
                        {
                            small = array[i][z];
                            row = i;
                            col = z;
                        }
                    }
                }
            array[row][col] = array[k][p];
            array[k][p] = small;
            System.out.print(array[k][p] + " ");
            }
            System.out.println();
        }
    }
}

Good Luck

Java 8 is now very common nowadays.

Arrays.sort(myArr,(double[] a,double[] b)->{
                //here multiple lines of code can be placed
                return a[0]-b[0]; 
            });

You can use your own sort, it is very simple.

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

for (int k = 0; k < length; k++) {
        for (int i= 0; i < matrix[k].length; i++) {
            for (int j = 0; j < matrix[k].length; j++) {
                if (matrix[k][i] < matrix[k][j]) {
                    int temp = matrix[k][i];
                    matrix[k][i] = matrix[k][j];
                    matrix[k][j] = temp;
                }
            }
        }
    }

System.out.println(Arrays.deepToString(matrix));

OUTPUT

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

There are multiple approaches to do this, Here I'm sharing follow two methods by which it can be achieved.

• Using Comparator Arrays.sort : An built-in feature of Java.
• Using Merge Sort

Using Comparator Arrays.sort : A built-in feature of Java.

import java.util.Arrays;

class Array2D {
    public static void printTwoDimensionArray(int [][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println("");
        }
    }

    public static void main(String [] args) {
        int [][] arr = {
                            {1, 2},
                            {6, 8},
                            {4, 7},
                            {9, 11},
                            {7, 10},
                            {13, 16},
                            {5, 9},
                            {8, 9},
                            {10, 11}
                        };
        Arrays.sort(arr, (a, b) -> Integer.compare(a[0], b[0]));
        printTwoDimensionArray(arr);
    }
}

Using Merge Sort

import java.util.ArrayList;

class MergeSortComparator {
    
    public static void printSingleDimensionArray(int [] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("");
    }

    public static void printDoublyDimensionArray(int [][] arr) {
       for (int i = 0; i < arr.length; i++) {
           for (int j = 0; j < arr[0].length; j++) {
               System.out.print(arr[i][j] + " ");
           }
           System.out.println("");
       }
    }

    public static void merge(int[][] arr, int start, int mid, int end, int index) {
        int i, j, k;
        int n1 = mid - start + 1;
        int n2 = end - mid;
        int columnLength = arr[0].length;
        int [][] leftSubArray = new int [n1][columnLength];
        int [][] rightSubArray = new int [n1][columnLength];
        
        // Copy elements to Temp LeftSubArray
        for (i = 0; i < n1; i++) {
            for (j = 0; j < columnLength; j++) {
                leftSubArray[i][j] = arr[start + i][j];
            }
        }

        // Copy elements to Temp RightSubArray
        for (i = 0; i < n2; i++) {
            for (j = 0; j < columnLength; j++) {
                rightSubArray[i][j] = arr[mid + 1 + i][j];
            }
        }

        i = j = k = 0;
        while(i < n1 && j < n2) {
            if (leftSubArray[i][index] <= rightSubArray[j][index]) {
                arr[start + k] = leftSubArray[i];
                i++;
            } else {
                arr[start + k] = rightSubArray[j];
                j++;
            }
            k++;
        }
        while(i < n1) {
            arr[start + k] = leftSubArray[i];
            i++;
            k++;
        }
        while(j < n2 && (start + k) < end) {
            arr[start + k] = rightSubArray[j];
            j++;
            k++;
        }
        
    }

    public static void mergeSort(int[][] arr, int start, int end, int index) {
        if (start >= end) {
            return;
        }
        int mid = (start + end) / 2;
        mergeSort(arr, start, mid, index);
        mergeSort(arr, mid + 1, end, index);
        merge(arr, start, mid, end, index);
        return;
    }
    
    public static void main(String [] args) {
        int [][] arr = {
                            {1, 2},
                            {6, 8},
                            {4, 7},
                            {9, 11},
                            {7, 10},
                            {13, 16},
                            {5, 9},
                            {8, 9},
                            {10, 11}
                        };
        
        int m = arr.length;
        int n = arr[0].length;
        // Last argument as Index is set to 0,
        mergeSort(arr, 0, m-1, 0);
        printDoublyDimensionArray(arr);
    }
}

To sort 2-D array lexicographically.
First sort each ArrayList in the Array<ArrayList>.

ArrayList<ArrayList<Integer>> allSubset = new ArrayList<>();

for(ArrayList<Integer> row : allSubset) {
     Collections.sort(row);
}

Second sort the whole ArrayList<ArrayList> in lexicographically.

allSubset.sort((ArrayList<Integer> o1, ArrayList<Integer> o2) -> {
            if(o2.size() == 0) return 1;
            int min = Math.min(o1.size(), o2.size());
            int i;
            for(i = 0; i < min - 1; i++) {
                if(o1.get(i).equals(o2.get(i))) continue;
                return o1.get(i).compareTo(o2.get(i));
            }
            return o1.get(i).compareTo(o2.get(i));
        });

or

        Collections.sort(allSubset, (ArrayList < Integer > first, ArrayList < Integer > second) -> {
            for (int i = 0; i < first.size() && i < second.size(); i++) {
                if (first.get(i) < second.get(i))
                    return -1;
                if (first.get(i) > second.get(i))
                    return 1;
            }
            if (first.size() > second.size())
                return 1;
            return -1;
        });

In java simply you can done by:

int[][] arr = {{4,5} , {1,2}};
Arrays.sort(arr , (int[] a , int[] b) -> a[0]-b[0]));

For a general solution you can use the Column Comparator. The code to use the class would be:

Arrays.sort(myArr, new ColumnComparator(0));