Use Overloaded Arrays#Sort(T[] a, Comparator c) which takes Comparator as the second argument.

double[][] array= {
{1, 5},
{13, 1.55},
{12, 100.6},
{12.1, .85} };

java.util.Arrays.sort(array, new java.util.Comparator<double[]>() {
    public int compare(double[] a, double[] b) {
        return Double.compare(a[0], b[0]);
    }
});

JAVA-8: Instead of that big comparator, we can use lambda function as following-

Arrays.sort(array, Comparator.comparingDouble(o -> o[0]));

There is an overloaded sort method in java.util.Arrays class which takes two arguments: the array to sort and a java.util.Comparator object.

You can add the following lines of code with your program to get the expected result.

import java.util.Arrays;
import java.util.Comparator;


Arrays.sort(testdatset, new Comparator<double[]>() {      
        @Override
        public int compare(double[] o1, double[] o2) {
            return Double.compare(o2[1], o1[1]);
        }
    });

The (a, b) -> Integer.compare(a[1], b[1]) is a lambda expression and in this case is an implementation of Comparator#compare(T,T). That method determines whether the first argument is less than, equal to, or greater than the second argument by returning a negative integer, zero, or a positive integer, respectively. The Integer.compare(int,int) method works the same way, just only with int arguments.

The sorting algorithm used by Arrays#sort(...) iterates over the array and compares its elements using the Comparator. The algorithm will consult the Comparator as many times as needed, using the results of the comparisons to determine which elements need to be moved, until the array is sorted.

A 2D array is essentially just an array of arrays. So what's happening is the "outer" array is being sorted based on the values at index 1 of the "inner" arrays.

If you're still unsure about the lambda expression it's equivalent to the following:

Arrays.sort(points, new Comparator<int[]>() {
  @Override
  public int compare(int[] a, int[] b) {
    int a1 = a[1];
    int b1 = b[1];

    // Integer.compare(a1, b1)
    if (a1 < b1) {
      return -1; // negative = less than
    } else if (a1 == b1) {
      return 0; // zero = equal to
    } else {
      return 1; // positive = greater than
    }
  }
});

Assuming points is an int[][].