使用 Arrays.sort() 对并行数组进行排序答案

【问题标题】：Sort a parallel array using Arrays.sort()使用 Arrays.sort() 对并行数组进行排序
【发布时间】：2013-09-21 00:25:48
【问题描述】：

是否可以使用Arrays.sort() 对数组进行排序，然后将另一个相关数组定位为与排序后的数组相同，例如：

    String arrNames[] = new String[5];
    String arrCellNo[] = new String[arrNames.length];


    String arrNamesSorted[] = new String[arrNames.length];
    System.arraycopy(arrNames, 0, arrNamesSorted, 0, arrNames.length);
    Arrays.sort(arrNamesSorted);

从这一点开始，我想做的是对 CellNo 数组进行排序，这样如果“person”有一个 cellNo “x”，那么在数组 arrNames 之后他将有相同的“cellNo”“x”排序

【问题讨论】：

标签： java arrays sorting parallel-arrays

【解决方案1】：

可以使用内置的 Arrays.sort 来归档效果，而无需为并行数组内容创建类。

注意索引应该是一个对象数组，而不是原始数组。（Arrays.sort(int[]) 不带比较器）

final int n = 10;
int[] values = new int[n];
Integer[] index = new Integer[n];
par_foreach(n, i -> index[i] = i);
par_foreach(n, i -> values[i] = random.nextInt(100));
Arrays.sort(index, (a, b) -> Integer.compare(values[a], values[b]));
println("values", values);
println("index", index);
print("ordered:");
foreach(n, i -> print(" " + values[index[i]]));
println();

备注

foreach :: Num -> (Num -> void) (parallel) par_foreach :: Num -> (Num -> void) 如果您无法想象实现： https://github.com/beenotung/javalib/blob/master/src/com/github/beenotung/javalib/Utils.java

【讨论】：

【解决方案2】：

我发现答案中引入的一些概念很难掌握，因此在我自己的解决方案中，我采用了不受欢迎的编程方法，以换取更容易理解的代码，并创建了冒泡排序方法，最后操纵了第二个数组，例如所以：

String arrNames[] = new String[5];
String arrCellNo[] = new String[arrNames.length];
String arrNamesSorted[] = new String[arrNames.length];
String arrCellNoSorted[] = new String[arrCellNo.length];

System.arraycopy(arrNames, 0, arrNamesSorted, 0, arrNames.length);
System.arraycopy(arrCellNo, 0, arrCellNoSorted, 0, arrCellNo.length);

for (int i = 0; i < arrNamesSorted.length; i++) {
    for (int j = 0; j <arrNamesSorted.length-1; j++) {
        if (arrNamesSorted[j].compareTo( arrNames[j+1])>0) {
            String temp = arrNamesSorted[i];
            arrNamesSorted[i] = arrNamesSorted[j];
            arrCellNoSorted[i] = arrCellNoSorted[j];
            arrNames[j] = temp;
            }
         }
   }

【讨论】：

【解决方案3】：

如果名称是唯一的，请考虑使用SortedMap：

final SortedMap<String,String> nameToCellNo = new TreeMap<>();
for (int i = 0; i < arrNames.length; i++) {
  nameToCellNo.put(arrNames[i], arrCellNo[i]);
}
int ctr = 0;
for (Map.Entry<String,String> entry : nameToCellNo.entrySet()) {
  arrNamesSorted[ctr] = entry.getKey();
  arrCellNoSorted[ctr++] = entry.getValue();
}

【讨论】：

【解决方案4】：

我会采用不同的方法：

创建一个新对象：

public class Person {
private name;
private cellNo;

// Implement getters and setters
}

创建一个比较器：

public MyComparator implements Comparator<Person> {
     public int compare(Person a, Person b) { 

           return a.getName().compareTo(b.getName());
     }
}

在 Person[] persons = ... 数组上调用 Array.sort(persons, new MyComparator())

【讨论】：

【解决方案5】：

您不能让Arrays.sort 像对第一个数组进行排序那样操作第二个数组。

解决方案是对包含您需要的所有数据的您自己的对象进行排序。创建具有名称和单元格编号属性的Contact 类。然后创建一个实现Comparator<Contact>（比如ContactComparator）的类来比较名称。

然后您将能够使用a particular overload of Arrays.sort 对Contact 对象的数组进行排序。

Arrays.sort(arrContacts, new ContactComparator());

所有数据都将保持井井有条，因为相同的名称仍将具有相同的单元格编号。

【讨论】：