Сортировка массива double по количеству знаков после запятой

Сортировать массив примитивных значений (double[], int[], long[] и т.п.) можно только в "естественном" порядке. Для необычной сортировки как в данном случае по длине дробной части потребуется либо использовать массив соответствующих классов-обёрток, т.е. Double[], к которому можно применить метод Arrays::sort(T[] a, Comparator<? super T> comp), либо преобразовать с помощью Stream API.

(Обновление) Для корректной сортировки нужно обеспечить ненулевое значение в старшем разряде (спасибо @Stanislav Volodarskiy).

Также потребуется обеспечить корректное форматирование некоторых чисел (спасибо @siarhei987), поскольку они могут быть по умолчанию преобразованы в строку с "научной" записью с указанием экспоненты.
Так как double может хранить до 17 значащих цифр, потребуется отформатировать каждое число, убрав нули в конце. При форматировании следует принять во внимание локаль, чтобы корректно обрабатывался десятичный разделитель

Double[] arr = {
    1.234, 1.2, 22d, 1.001, 23.41, 10.00456, 3.1415, Math.PI
};

Arrays.sort(arr, Comparator.comparingLong(x -> {
    String s = String.format(Locale.US, "%.17f", x).replaceAll("0+$", "");
    return Long.parseLong(1 + s.substring(s.indexOf(".") + 1));
}));

System.out.println(Arrays.toString(arr));
// -> [22.0, 1.2, 23.41, 1.001, 1.234, 3.1415, 10.00456, 3.141592653589793]

Аналогично:

double[] arr = {
    1.234, 1.2, 22, 1.001, 23.41, 10.00456, 3.1415, 11.21, Math.PI, 
    10.234, 1238.41,
    12345678.02,          // 10 знаков 8+2 
    12345678901234.5678,  // 18 знаков 14+4
    1234567890999.56789,  // 18 знаков 13+5
  -.123456789012345678,   // 18 знаков 0+18
-12.3456789012345678,     // 18 знаков 2+16
    987654321012345678.91 // 20 знаков 18+2
};

arr = Arrays.stream(arr)
    .boxed()
    .sorted(Comparator.comparingLong(
        x -> Long.parseLong(1 + String.format(Locale.US, "%.17f", x)
            .replaceAll("0+$", "")    // удалить 0 в конце
            .replaceAll("^.*\\.", "") // удалить всё до точки в начале
        )
    ))
    .mapToDouble(x -> x)
    .toArray();

for (double d : arr) {
    System.out.println(String.format(Locale.US, "%.17f", d).replaceAll("\\.?0+$", ""));
}

Некоторые числа будут округлены, так как у типа double не хватает точности

22
987654321012345730
1.2
12345678.02
11.21
23.41
1238.41
1.001
1.234
10.234
12345678901234.568
3.1415
1234567890999.5679
10.00456
3.141592653589793
-12.345678901234567
-0.12345678901234568

fracLength вычисляет длину дробной части числа. format переводит double в десятичную дробь. 330 - волшебная константа: самое маленькое значение double - 4.9E-324, значит трехсот тридцати знаков будет достаточно для любого конечного значения. Первый replaceFirst удаляет знак, целую часть и десятичную точку. Второй удаляет хвост из нулей. Длина остатка - то что нам нужно:

    private static int fracLength(double d) {
        return String
            .format("%.330f", d)
            .replaceFirst(".*\\.", "")
            .replaceFirst("0*$", "")
            .length();
    }

Java умеет сортировать double[] только по значениям. А нам нужно по ключу. Массив можно обернуть в список List<Double>. Приятно, что данные не надо копировать: новый список - интерфейс к массиву, не более:

    private static List<Double> wrap(double[] a) {
        return new AbstractList<Double>() {
            @Override
            public Double get(int index) {
                return a[index];
            } 

            @Override public int size() {
                return a.length;
            }

            @Override
            public Double set(int index, Double element) {
                final double previous = a[index];
                a[index] = element;
                return previous;
            }
        };
    }

Список уже можно сортировать по ключу. В результате сортируется сам массив:

    private static void sortByFracLength(double[] a) {
        Collections.sort(wrap(a), Comparator.comparingInt(d -> fracLength(d)));
    }

Тестируем решение:

import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Temp {
    private static List<Double> wrap(double[] a) {
        return new AbstractList<Double>() {
            @Override
            public Double get(int index) {
                return a[index];
            } 

            @Override public int size() {
                return a.length;
            }

            @Override
            public Double set(int index, Double element) {
                final double previous = a[index];
                a[index] = element;
                return previous;
            }
        };
    }

    private static int fracLength(double d) {
        return String
            .format("%.330f", d)
            .replaceFirst(".*\\.", "")
            .replaceFirst("0*$", "")
            .length();
    }

    private static void sortByFracLength(double[] a) {
        Collections.sort(wrap(a), Comparator.comparingInt(d -> fracLength(d)));
    }

    public static void main(String[] args) {
        double[] a = {
            Double.MIN_VALUE,
            Double.MAX_VALUE,
            10.2,
            10.0001,
            1234,
            1234.01234
        };
        System.out.println(Arrays.toString(a));
        sortByFracLength(a);
        System.out.println(Arrays.toString(a));
    }
}

$ javac Temp.java && java Temp
[4.9E-324, 1.7976931348623157E308, 10.2, 10.0001, 1234.0, 1234.01234]
[1.7976931348623157E308, 1234.0, 10.2, 10.0001, 1234.01234, 4.9E-324]