Массив сортировки Java

Question

Я знаю, как сортировать массив, который имеет два столбца:

Arrays.sort(myarray, new Comparator<String[]>() {
                     @Override
                     public int compare(String[] entry1, String[] entry2) {
                         String time1 = entry1[0];
                         String time2 = entry2[0];
                         return time2.compareTo(time1);
                     }
                });

Это сортирует массив по первому столбцу.Но что, если у меня будет больше столбцов?Например,

myarray[0][0]= +3620205252
myarray[0][1]= 32534
myarray[0][2]= Franco Nera
myarray[0][3]= 183
myarray[1][0]= +3658300234
myarray[1][1]= 4334
myarray[1][2]= Judy Moira
myarray[1][3]= 28

и т. Д. Я хочу отсортировать это, например, по второму столбцу или четвертому столбцу ... Я могу попытаться решить это, создав новый массив [1-й + 3-й + 4-й столбец] [2-й столбец], а затем отсортируйте его с помощью приведенного выше решения, затем разберите элементы на части, но это слишком косвенно.

Answer 1

Для сортировки по другому столбцу просто замените [0] в следующих строках:

String time1 = entry1[0];
String time2 = entry2[0];

Если вы хотите отсортировать по нескольким столбцам, высначала нужно сравнить по предпочтению наивысшего порядка, например:

String time1 = entry1[0];
String time2 = entry2[0];
int cmp = time2.compareTo(time1);

, а затем, если результат равен нулю (т. е. они равны), сравнить по следующему наивысшему предпочтению:

if (cmp == 0) {
    String s1 = entry1[1];
    String s2 = entry2[1];
    cmp = s2.compareTo(s1);
}

return cmp;

Answer 2

Вот пример:

public static class ColumnComparator<T extends Comparable>
        implements Comparator<T[]> {
    private int column;

    public ColumnComparator(int column) {
        this.column = column;
    }

    public int compare(T[] o1, T[] o2) {
        return o1[column].compareTo(o2[column]);
    }
}

Используется так:

Arrays.sort(myarray, new ColumnComparator<String>(1));

Можно легко обобщить сравнение нескольких столбцов.

Answer 3

Это то же самое, что и с двумя столбцами, но с большим количеством столбцов: вы можете сортировать по любому или нескольким столбцам, сколько хотите, если ваш компаратор проверяет столбцы, которые вам нужны.

Чтобы отсортировать по нескольким столбцам, вам нужно определить порядок сравнения и вернуть результат compareTo, как только у вас появятся неравные столбцы.

Тангенциально, зачем вам использовать массивы для этого?Это Java, может также использоваться как объект или что-то в этом роде.

Answer 4

Вам нужно пройтись по двум массивам, пока вы не найдете индекс, где элементы отличаются, и не вернете сравнение строк с этим индексом. Это в основном та же идея, которая используется при сравнении строк.

for(int i=0;i<Math.min(entry1.length,entry2.length);i++){
   String x=entry1[i], y=entry2[i];
   int diff=x.compareTo(y);
   if (diff!=0) return diff;
}
if (entry1.length==entry2.length) return 0;
else return entry1.length-entry2.length;

Код выше также обрабатывает случай, когда массивы могут иметь разное количество столбцов.

Answer 5

Я думаю, что самый простой способ - использовать временный массив строк, поскольку у вас есть массив строк -

Пример массива:

String array[][][] = {
        {
            {"Hello", "World"},
            {"Apple", "Orange"}
        },
        {
            {"Zebra", "Cow"},
            {"Cat", "Ball"}
        },
        {
            {"Elephant", "Whale"},
            {"Lion", "Monkey"}
        }                
};

Временный массив строк:

String[] tempArray = new String[array.length * array[0].length * array[0][0].length];

Заполните временный массив:

int tempIndex = 0;
for(int i=0; i<array.length; i++) {
    for(int j=0; j<array[i].length; j++) {
        for(int k=0; k<array[i][j].length; k++) {
            System.out.println("array[" + i + "][" + j + "][" + k + "]: " + array[i][j][k]);
            tempArray[tempIndex++] = array[i][j][k];
        }
    }
}

Это также печатает -

array[0][0][0]: Hello
array[0][0][1]: World
array[0][1][0]: Apple
array[0][1][1]: Orange
array[1][0][0]: Zebra
array[1][0][1]: Cow
array[1][1][0]: Cat
array[1][1][1]: Ball
array[2][0][0]: Elephant
array[2][0][1]: Whale
array[2][1][0]: Lion
array[2][1][1]: Monkey

Теперь, сортируйте временный массив -

Arrays.sort(tempArray);

ЗаполнитеИсходный массив с отсортированными значениями -

tempIndex = 0;
for(int i=0; i<array.length; i++) {
    for(int j=0; j<array[i].length; j++) {
        for(int k=0; k<array[i][j].length; k++) {                    
            array[i][j][k] = tempArray[tempIndex++];
        }
    }
}

Теперь, если вы снова печатаете элементы исходного массива, он должен вывести -

array[0][0][0]: Apple
array[0][0][1]: Ball
array[0][1][0]: Cat
array[0][1][1]: Cow
array[1][0][0]: Elephant
array[1][0][1]: Hello
array[1][1][0]: Lion
array[1][1][1]: Monkey
array[2][0][0]: Orange
array[2][0][1]: Whale
array[2][1][0]: World
array[2][1][1]: Zebra