在Java中,如何按外观顺序对多维数组进行排序?
如果标题不清楚,让我举个例子: 我得到了一个按第一列排序的数组-在Java中,如何按外观顺序对多维数组进行排序?,java,sorting,multidimensional-array,Java,Sorting,Multidimensional Array,如果标题不清楚,让我举个例子: 我得到了一个按第一列排序的数组-date,我需要按照列name data[100][4] date | name | text | type -----+------+------+------ 2222 | z | wwww | 2 2221 | z | qqqq | 1 2220 | c | dasa | 2 2219 | b | dsad | 1 2218 | z | dfsa | 2 2217 | c | dasd |
date
,我需要按照列name
data[100][4]
date | name | text | type
-----+------+------+------
2222 | z | wwww | 2
2221 | z | qqqq | 1
2220 | c | dasa | 2
2219 | b | dsad | 1
2218 | z | dfsa | 2
2217 | c | dasd | 1
这是排序后的数组:
order[100][4]
date | name | text | type
-----+------+------+------
2222 | z | wwww | 2
2221 | z | qqqq | 1
2218 | z | dfsa | 2
2220 | c | dasa | 2
2217 | c | dasd | 1
2219 | b | dsad | 1
我考虑将这些数据合并成一个字符串,并在列之间插入一些符号,以便将来检索它,添加到ArrayList
,然后按名称检索。我已经将data[I][1]
添加到HashMap
以确定唯一值的数量,这样我就可以知道循环周期的数量。还有名称值的顺序,这让我感到困惑,因为HashMap
无法维持顺序
有人知道如何不费吹灰之力地对其进行排序吗?将此2d数组转换为HashMap。对象部分将保存该特定数组元素 获取密钥集。。将键集转换为列表。。将此列表排序。。迭代列表并从映射中获取它们各自的数组元素 e、 g代码:
String[][] myArr = new String[4][3];
for (int i=0; i<myArr.length; i++) {
myArr[i][0] = (i+1)+"1";
myArr[i][1] = (i+1)+"2";
myArr[i][2] = (i+1)+"3";
}
Map<String, Object> map = new HashMap<String, Object>();
for (int i=myArr.length-1; i>=0; i--) {
map.put(myArr[i][0], myArr[i]);
}
List<String> keyList = new ArrayList<String>(map.keySet());
Collections.sort(keyList);
String[][] myNewArray = new String[4][3];
int a =0;
for (String s : keyList) {
myNewArray[a++] = ((String[])map.get(s));
}
String[][]myArr=新字符串[4][3];
对于(int i=0;i=0;i--){
map.put(myArr[i][0],myArr[i]);
}
List keyList=newarraylist(map.keySet());
集合。排序(键列表);
字符串[][]myNewArray=新字符串[4][3];
int a=0;
用于(字符串s:键列表){
myNewArray[a++]=((String[])map.get(s));
}
我使用的是字符串,在你的例子中是date。即使是其他内容,也可以使用comparable或compactor对该键列表进行排序
使用您的排序键作为映射中的键。有一个对象,该对象表示具有日期、名称、文本和类型的数据条目,并使其实现
可比较的界面。Comparable
接口有效地允许对对象执行不平等操作,并且是Java API用于对对象进行任何排序比较(用于排序)的接口。然后,要根据给定字段对数据进行排序,请在数据对象类中包含一个静态变量,该变量表示要对哪个字段进行排序
class Data implements Comparable<Data>
{
int date; // field 1
String name; // field 2
String text; // field 3
int type; // field 4
static int sortField;
static final int DATE = 1;
static final int NAME = 2;
static final int TEXT = 3;
static final int TYPE = 4;
// put constructor here
//compareTo function for sorting
public int compareTo(Data other)
{
if (sortField == DATE)
{
if (date < other.date) return -1;
if (date > other.date) return 1;
else return 0;
}
if (sortField == NAME)
{
return name.compareTo(other.name);
}
if (sortField == TEXT)
{
return text.compareTo(other.text);
}
else
{
if (type < other.type) return -1;
if (type > other.type) return 1;
else return 0;
}
}
}
我使用了@Aderis创建类的想法,但排序方法略有不同。此处发布了初始化数组的代码,但有人将其删除。反正我也用过
String[][] myArr = { { "2222", "b", "dfsa", "2" },
{ "2221", "z", "wwww", "2" }, { "2220", "c", "qqqq", "1" },
{ "2219", "z", "dasa", "2" }, { "2218", "b", "dsad", "1" } };
HashMap<String,String> hashData = new HashMap<>();
for (int i = 0; i < myArr.length; i++) hashData.put(myArr[i][1],myArr[i][1]);
int unique_entries = hashData.size();
ArrayList<Data> list = new ArrayList<Data>();
ArrayList<Data> list_sorted = new ArrayList<Data>();
for (int i = 0; i < myArr.length; i++){
Data temp = new Data(myArr[i][0],myArr[i][1],myArr[i][2],Integer.parseInt(myArr[i][3]));
list.add(temp);
}
for (int k = 0; k < unique_entries; k++){
boolean flag = true;
ArrayList<Integer> elements = new ArrayList<>();
int list_elements = list.size();
for (int i = 0; i < list_elements; i++){
if (flag){
list_sorted.add(list.get(i));
elements.add(i);
flag = false;
continue;
}
int list_sorted_elements = list_sorted.size();
for (int j = 0; j < list_sorted_elements; j++){
if (list_sorted.get(j).name.contains(list.get(i).name)){
list_sorted.add(list.get(i));
elements.add(i);
break;
}
}
}
for (int i = 0; i < elements.size(); i++){
int temp = elements.get(i);
if (i != 0) temp = temp - i;
list.remove(temp);
}
}
String[]myArr={{{“2222”,“b”,“dfsa”,“2”},
{“2221”,“z”,“wwww”,“2”},{“2220”,“c”,“qqqq”,“1”},
{“2219”、“z”、“dasa”、“2”}、{“2218”、“b”、“dsad”、“1”};
HashMap hashData=新HashMap();
对于(int i=0;i
如您所见,为了确定唯一元素的数量,我将它们添加到HashMap
并检查其大小。我用我的数据对象填充一个ArrayList
,并将排序后的数据添加到另一个ArrayList
,然后从未排序的列表中删除这些数据,并开始对其余数据进行排序。循环的数量与唯一名称的数量相同
我不认为这是一个最佳的方式。但这是我知道的唯一方法。如果有人知道更快的方式,我将接受他们的帖子。如果您想要顺序,LinkedHashMap将保留插入顺序。使用Java集合和比较器。但在这里,它将是一维数组。问题是多维数组。@RamanShrivastava列表中的数据对象包含多个数据点,这些数据点首先使数组成为多维数组。明白了。但是如果我的其他类型的多维数组。。或者我想介绍一些专栏。这将如何处理?您可以使类动态化。您可以使用一个ArrayList代替每个字段的变量,在列表中以任意顺序存储每个字段,然后使compareTo()只返回list.get(sortField).compareTo(other.list.get(sortField))。sortField将是ArrayList中字段的索引。您的代码可以按照字母顺序对我的数据进行排序,并且我指定了顺序必须是外观。比如:z,b,c,z,c,z,b
被排序z,z,z,b,b,c,c
我猜你不明白这个问题。数组中的数据已按日期排序,需要按名称排序
String[][] myArr = { { "2222", "b", "dfsa", "2" },
{ "2221", "z", "wwww", "2" }, { "2220", "c", "qqqq", "1" },
{ "2219", "z", "dasa", "2" }, { "2218", "b", "dsad", "1" } };
HashMap<String,String> hashData = new HashMap<>();
for (int i = 0; i < myArr.length; i++) hashData.put(myArr[i][1],myArr[i][1]);
int unique_entries = hashData.size();
ArrayList<Data> list = new ArrayList<Data>();
ArrayList<Data> list_sorted = new ArrayList<Data>();
for (int i = 0; i < myArr.length; i++){
Data temp = new Data(myArr[i][0],myArr[i][1],myArr[i][2],Integer.parseInt(myArr[i][3]));
list.add(temp);
}
for (int k = 0; k < unique_entries; k++){
boolean flag = true;
ArrayList<Integer> elements = new ArrayList<>();
int list_elements = list.size();
for (int i = 0; i < list_elements; i++){
if (flag){
list_sorted.add(list.get(i));
elements.add(i);
flag = false;
continue;
}
int list_sorted_elements = list_sorted.size();
for (int j = 0; j < list_sorted_elements; j++){
if (list_sorted.get(j).name.contains(list.get(i).name)){
list_sorted.add(list.get(i));
elements.add(i);
break;
}
}
}
for (int i = 0; i < elements.size(); i++){
int temp = elements.get(i);
if (i != 0) temp = temp - i;
list.remove(temp);
}
}