Как отсортировать конкретный 2-мерный массив в Java

Question

Я пытаюсь отсортировать следующий массив:

int hitlist[][] = new int [17][2];

Сортировка информации всегда выполняется в hitlist[i][0], и она числовая, но я не могу найти правильный путь для Arrays.sort.

Ввод выглядит как:

[0, 0] 
[4, 0] 
[3, 1] 
[4, 2] 
[4, 4] 
[5, 6] 
[4, 7] 
[4, 8] 
[1, 9] 
[4, 11] 
[4, 12] 
[2, 13] 
[4, 14] 
[4, 15] 
[0, 0] 
[0, 0] 
[0, 0] 

, и теперь я хочу, чтобы он был отсортирован как:

[1, 9]
[2, 13]
[3, 1]
[4, 0]
[4, 2] 
[4, 4]
[4, 7] 
[4, 8]
[4, 11] 
[4, 12]
[4, 14] 
[4, 15]

Answer 1

Вы можете поместить массивы int в массивы Integer и затем сравнить численно два объекта Integer (объекты с 0-м индексом) в лямбда-функции.

И затем просто передать этот компаратор в Arrays.sort, который будет сортироватьэто в соответствии с порядком, индуцированным компаратором.

    Integer[][] array= {
            {1, 3},
            {10, 5},
            {4, 100},
            {12, 30} };

    Comparator<Integer[]> arrayComparator = (a1, a2) -> a1[0].compareTo(a2[0]);

    Arrays.sort(array, arrayComparator);

Answer 2

Если вы хотите отсортировать массив на основе индекса, вы можете использовать Arrays::sort с Comparator::comparingInt

int index = 0;
Arrays.sort(hitlist, Comparator.comparingInt(arr -> arr[index]));

Вот пример в Ideone

---

Редактировать

На основании вашего комментария и комментария , вы хотитечтобы игнорировать [0, 0] из вашего массива после сортировки, в этом случае вы можете использовать:

int[][] hitlist = {{0, 0}, {4, 0}, {3, 1}, {4, 2}, {4, 4}, {5, 6}, {4, 7}, {4, 8}, {1, 9}, {4, 11}, {4, 12}, {2, 13}, {4, 14}, {4, 15}, {0, 0}, {0, 0}, {0, 0}};
int index = 0;
int[][] sortedArray = Arrays.stream(hitlist)
        .filter(arr -> arr[0] != 0 && arr[1] != 0)
        .sorted(Comparator.comparingInt(arr -> arr[index]))
        .toArray(int[][]::new);

Ideone demo

Выходы

[1, 9]
[2, 13]
[3, 1]
[4, 2]
[4, 4]
[4, 7]
[4, 8]
[4, 11]
[4, 12]
[4, 14]
[4, 15]
[5, 6]

Answer 3

Хотя я предпочитаю решение YCF_L , в этой реализации используется быстрая сортировка с компаратором целочисленных массивов.Это обеспечивает большую гибкость.

import java.util.Arrays;

/**
 * Based on Quicksort (right-most pivot) implementation from:  
 * https://www.programcreek.com/2012/11/quicksort-array-in-java/
 */
public class Sorter {
    private static interface IntArrayComparator {
        int compare(int[] a, int[] b);
    }

    public static void main(String[] args) {
        int hitlist[][] = new int[8][2];
        hitlist[4] = new int[] { 4, 10000 };
        hitlist[1] = new int[] { 1, 10 };
        hitlist[5] = new int[] { 5, 100000 };
        hitlist[0] = new int[] { 0, 1 };
        hitlist[2] = new int[] { 2, 100 };
        hitlist[7] = new int[] { 7, 10000000 };
        hitlist[3] = new int[] { 3, 1000 };
        hitlist[6] = new int[] { 6, 1000000 };

        quickSort(hitlist, (a, b) -> a[0] - b[0]);
        Arrays.asList(hitlist).stream().map(Arrays::toString).forEach(System.out::println);
    }

    public static void quickSort(int[][] arr, IntArrayComparator comparator) {
        quickSort(arr, comparator, 0, arr.length - 1);
    }

    public static void quickSort(int[][] arr, IntArrayComparator comparator, int start, int end) {
        int partition = partition(arr, comparator, start, end);
        if (partition - 1 > start) {
            quickSort(arr, comparator, start, partition - 1);
        }
        if (partition + 1 < end) {
            quickSort(arr, comparator, partition + 1, end);
        }
    }

    public static int partition(int[][] arr, IntArrayComparator comparator, int start, int end) {
        int[] pivot = arr[end];
        for (int i = start; i < end; i++) {
            if (comparator.compare(arr[i], pivot) < 0) {
                int[] temp = arr[start];
                arr[start] = arr[i];
                arr[i] = temp;
                start++;
            }
        }
        int[] temp = arr[start];
        arr[start] = pivot;
        arr[end] = temp;
        return start;
    }
}

Результат

[0, 1]
[1, 10]
[2, 100]
[3, 1000]
[4, 10000]
[5, 100000]
[6, 1000000]
[7, 10000000]

Answer 4

Это зависит от того, хотите ли вы сортировать строку или столбцы.

Допустим, вы хотите отсортировать каждую строку, что вы можете сделать.

for(int i=0; i < hitlist.size(); i++ {
     Array.sort(hitlist[i]);
}

сортировка столбца становится сложной, в результате чегоВ этом случае вы можете создать новый массив, содержащий значения столбцов, и отсортировать или повернуть столбец по строкам (90 градусов), отсортировать его как строки и повернуть обратно (-90 градусов)

, если вам нужно что-то еще, вы должныосуществить поиск самостоятельно.

Надеюсь, это поможет