I am looking to sort the following array based on the values of [][0]
double[][] myArr = new double[mySize][2];
so for example, myArr contents is:
1 5
13 1.55
12 100.6
12.1 .85
I want it to get to:
1 5
12 100.6
12.1 .85
13 1.55
I am looking to do this without having to implement my own sort.
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
Simplified Java 8
IntelliJ suggests to simplify the top answer to the:
Arrays.sort(queries, Comparator.comparingDouble(a -> a[0]));
Welcome Java 8:
Arrays.sort(myArr, (a, b) -> Double.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]);
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];
});
The simplest way:
Arrays.sort(myArr, (a, 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));
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]
for decreasing order for 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]);//decreasing order
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
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.
Source: Stackoverflow.com