Сортировка двухмерного массива на основе одного столбца
В Java у меня есть данные в моем массиве, например, следующие
2009.07.25 20:24 Message A
2009.07.25 20:17 Message G
2009.07.25 20:25 Message B
2009.07.25 20:30 Message D
2009.07.25 20:01 Message F
2009.07.25 21:08 Message E
2009.07.25 19:54 Message R
Я хотел бы отсортировать его по первому столбцу, поэтому мои окончательные данные могут выглядеть так:
2009.07.25 19:54 Message R
2009.07.25 20:01 Message F
2009.07.25 20:17 Message G
2009.07.25 20:24 Message A
2009.07.25 20:25 Message B
2009.07.25 20:30 Message D
2009.07.25 21:08 Message E
Первый столбец - это дата формата "yyyy.MM.dd HH: mm", а второй столбец - строка.
Ответы
Ответ 1
Сортировка двухмерного массива на основе одного столбца Первый столбец - это дата формата "yyyy.MM.dd HH: mm", а второй столбец - строка.
Поскольку вы говорите двухмерный массив, я предполагаю, что "дата формата..." означает строку. Здесь код для сортировки двухмерного массива String [] []:
import java.util.Arrays;
import java.util.Comparator;
public class Asdf {
public static void main(final String[] args) {
final String[][] data = new String[][] {
new String[] { "2009.07.25 20:24", "Message A" },
new String[] { "2009.07.25 20:17", "Message G" },
new String[] { "2009.07.25 20:25", "Message B" },
new String[] { "2009.07.25 20:30", "Message D" },
new String[] { "2009.07.25 20:01", "Message F" },
new String[] { "2009.07.25 21:08", "Message E" },
new String[] { "2009.07.25 19:54", "Message R" } };
Arrays.sort(data, new Comparator<String[]>() {
@Override
public int compare(final String[] entry1, final String[] entry2) {
final String time1 = entry1[0];
final String time2 = entry2[0];
return time1.compareTo(time2);
}
});
for (final String[] s : data) {
System.out.println(s[0] + " " + s[1]);
}
}
}
Вывод:
2009.07.25 19:54 Message R
2009.07.25 20:01 Message F
2009.07.25 20:17 Message G
2009.07.25 20:24 Message A
2009.07.25 20:25 Message B
2009.07.25 20:30 Message D
2009.07.25 21:08 Message E
Ответ 2
class ArrayComparator implements Comparator<Comparable[]> {
private final int columnToSort;
private final boolean ascending;
public ArrayComparator(int columnToSort, boolean ascending) {
this.columnToSort = columnToSort;
this.ascending = ascending;
}
public int compare(Comparable[] c1, Comparable[] c2) {
int cmp = c1[columnToSort].compareTo(c2[columnToSort]);
return ascending ? cmp : -cmp;
}
}
Таким образом, вы можете обрабатывать любые типы данных в этих массивах (если они сопоставимы), и вы можете сортировать любой столбец в порядке возрастания или убывания.
String[][] data = getData();
Arrays.sort(data, new ArrayComparator(0, true));
PS: убедитесь, что вы проверили ArrayIndexOutOfBounds и другие.
EDIT: вышеупомянутое решение было бы полезно только в том случае, если вы действительно сможете хранить java.util.Date в первом столбце, или если ваш формат даты позволяет вам использовать обычное сравнение строк для этих значений. В противном случае вам нужно преобразовать эту строку в дату, и вы можете добиться этого с помощью интерфейса обратного вызова (в качестве общего решения). Здесь расширенная версия:
class ArrayComparator implements Comparator<Object[]> {
private static Converter DEFAULT_CONVERTER = new Converter() {
@Override
public Comparable convert(Object o) {
// simply assume the object is Comparable
return (Comparable) o;
}
};
private final int columnToSort;
private final boolean ascending;
private final Converter converter;
public ArrayComparator(int columnToSort, boolean ascending) {
this(columnToSort, ascending, DEFAULT_CONVERTER);
}
public ArrayComparator(int columnToSort, boolean ascending, Converter converter) {
this.columnToSort = columnToSort;
this.ascending = ascending;
this.converter = converter;
}
public int compare(Object[] o1, Object[] o2) {
Comparable c1 = converter.convert(o1[columnToSort]);
Comparable c2 = converter.convert(o2[columnToSort]);
int cmp = c1.compareTo(c2);
return ascending ? cmp : -cmp;
}
}
interface Converter {
Comparable convert(Object o);
}
class DateConverter implements Converter {
private static final DateFormat df = new SimpleDateFormat("yyyy.MM.dd hh:mm");
@Override
public Comparable convert(Object o) {
try {
return df.parse(o.toString());
} catch (ParseException e) {
throw new IllegalArgumentException(e);
}
}
}
И на этом этапе вы можете отсортировать в своем первом столбце:
Arrays.sort(data, new ArrayComparator(0, true, new DateConverter());
Я пропустил проверки на ошибки и другие проблемы с обработкой ошибок.
Я согласен, что это уже похоже на структуру.:)
Последнее (надеюсь) редактирование: теперь я понимаю, что ваш формат даты позволяет использовать простое сравнение строк. Если это так, вам не нужна "улучшенная версия".
Ответ 3
Arrays.sort(yourarray, new Comparator() {
public int compare(Object o1, Object o2) {
String[] elt1 = (String[])o1;
String[] elt2 = (String[])o2;
return elt1[0].compareTo(elt2[0]);
}
});
Ответ 4
Предполагая, что ваш массив содержит строки, вы можете использовать следующее:
String[] data = new String[] {
"2009.07.25 20:24 Message A",
"2009.07.25 20:17 Message G",
"2009.07.25 20:25 Message B",
"2009.07.25 20:30 Message D",
"2009.07.25 20:01 Message F",
"2009.07.25 21:08 Message E",
"2009.07.25 19:54 Message R"
};
Arrays.sort(data, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
String t1 = s1.substring(0, 16); // date/time of s1
String t2 = s2.substring(0, 16); // date/time of s2
return t1.compareTo(t2);
}
});
Если у вас двумерный массив, решение также очень похоже:
String[][] data = new String[][] {
{ "2009.07.25 20:17", "Message G" },
{ "2009.07.25 20:25", "Message B" },
{ "2009.07.25 20:30", "Message D" },
{ "2009.07.25 20:01", "Message F" },
{ "2009.07.25 21:08", "Message E" },
{ "2009.07.25 19:54", "Message R" }
};
Arrays.sort(data, new Comparator<String[]>() {
@Override
public int compare(String[] s1, String[] s2) {
String t1 = s1[0];
String t2 = s2[0];
return t1.compareTo(t2);
}
});
Ответ 5
код:
import java.util.Arrays;
import java.util.Comparator;
class SortString {
public static void main(final String[] args) {
final String[][] data = new String[][] {
new String[] { "2009.07.25 20:24", "Message A" },
new String[] { "2009.07.25 20:17", "Message G" },
new String[] { "2009.07.25 20:25", "Message B" },
new String[] { "2009.07.25 20:30", "Message D" },
new String[] { "2009.07.25 20:01", "Message F" },
new String[] { "2009.07.25 21:08", "Message E" },
new String[] { "2009.07.25 19:54", "Message R" }
};
// this is applicable only in java 8 version.
Arrays.sort(data, (String[] s1, String[] s2) -> s1[0].compareTo(s2[0]));
// we can also use Comparator.comparing and point to Comparable value we want to use
// Arrays.sort(data, Comparator.comparing(row->row[0]));
for (final String[] s : data) {
System.out.println(s[0] + " " + s[1]);
}
}
}
Выход
2009.07.25 19:54 Message R
2009.07.25 20:01 Message F
2009.07.25 20:17 Message G
2009.07.25 20:24 Message A
2009.07.25 20:25 Message B
2009.07.25 20:30 Message D
2009.07.25 21:08 Message E
Ответ 6
Просмотрите ColumnComparator. Это в основном то же самое решение, что было предложено Costi, но оно также поддерживает сортировку по столбцам в списке и имеет еще несколько свойств сортировки.
Ответ 7
Использование Lambdas с java 8:
final String[][] data = new String[][] { new String[] { "2009.07.25 20:24", "Message A" },
new String[] { "2009.07.25 20:17", "Message G" }, new String[] { "2009.07.25 20:25", "Message B" },
new String[] { "2009.07.25 20:30", "Message D" }, new String[] { "2009.07.25 20:01", "Message F" },
new String[] { "2009.07.25 21:08", "Message E" }, new String[] { "2009.07.25 19:54", "Message R" } };
String[][] out = Arrays.stream(data).sorted(Comparator.comparing(x -> x[1])).toArray(String[][]::new);
System.out.println(Arrays.deepToString(out));
Вывод:
[[2009.07.25 20:24, Сообщение A], [2009.07.25 20:25, Сообщение B], [2009.07.25 20:30, Сообщение D], [2009.07.25 21:08, Сообщение E], [2009.07.25 20:01, Сообщение F], [2009.07.25 20:17, Сообщение G], [2009.07.25 19:54, Сообщение R]]
