Java 对两个并行数组进行排序

我有两个数组，一个存储城市的距离，另一个存储相应的人口。如果城市之间的距离按升序排列，一切都会正常进行。 但是假设有人随机输入了距离。如何对城市数组进行排序，并确保各个城市的人口与其各自城市人口的指数处于相同的指数中

例如：

• 城市1有人口333
• 第三城人口33333人
• 第五城人口33

int[]city={1,3,5}；
int[]pop={33333333,33}；

一切正常，因为城市数组已经排序

但当我输入：

int[]city={3,1,5}；
int[]pop={33333333}；

大问题

我希望对数组city进行排序，并确保population数组的所有元素都与各自的city位于同一索引中。

一种“便宜”的方法是使用第三个数组，其中包含0到n表示其他数组的索引

但是，如果将它们分组在一个类中，您遇到的问题就会消失，这两个信息似乎在逻辑上是相关的。

---

然后您将实现Comparable:

实现这一点的好方法是使用city类：

class City{
    private int id;
    private long population;

    //... getters, setters, etc
}

城市比较级：

class CityPopulationComparator implements Comparator<City> {
    @Override
    public int compare(City c1, City c2) {
        return Long.compare(c1.getPopulation(), c2.getPopulation());
    }
}

---

但是如果您需要以这种方式拥有您的城市和人口，您可以自己编写一种排序方法（例如气泡排序），并且每当您交换两个城市时，也可以交换相应的人口。

如果您的城市id是唯一的：

int[]city={3,1,5}；
int[]pop={33333333}；
Map arr=新HashMap（city.length）；
for（int i=0；i

同样使用

int[]city={3,1,5}；
int[]pop={33333333}；
SortedMap arr=新树映射（）；
for（int i=0；i

正确的解决方案是。但是，如果你想要一个完全疯狂的黑客，你可以这样做：

public final class ParallelIntArrays extends AbstractList<int[]> {

    private final int[] array1;
    private final int[] array2;

    public ParallelIntArrays(int[] array1, int[] array2) {
        if (array1.length != array2.length)
            throw new IllegalArgumentException();
        this.array1 = array1;
        this.array2 = array2;
    }

    @Override
    public int[] get(int i) {
        return new int[] { array1[i], array2[i] };
    }

    @Override
    public int size() {
        return array1.length;
    }

    @Override
    public int[] set(int i, int[] a) {
        if (a.length != 2)
            throw new IllegalArgumentException();
        int[] b = get(i);
        array1[i] = a[0];
        array2[i] = a[1];
        return b;
    }
}

请注意，如上所述，

ParallelIntArrays

不能作为

列表正常工作。例如
list.contains（list.get（0））
将给出
false
。如果您将其改为
列表
或
列表
，它将被修复。
公共静态void main（字符串[]args）{
整数[]bidAmount={3000,54000,2000,1000,5600}；
String[]bidderName={“Jenny”、“Mike”、“Alvin”、“Berry”、“John”}；
Map stringTreeMap=newtreemap（）；
stringTreeMap.put（bidAmount[0]，bidderName[0]）；
stringTreeMap.put（bidAmount[1]，bidderName[1]）；
stringTreeMap.put（bidAmount[2]，bidderName[2]）；
stringTreeMap.put（bidAmount[3]，bidderName[3]）；
stringTreeMap.put（bidAmount[4]，bidderName[4]）；
对于（Map.Entry:stringTreeMap.entrySet（））{
整数key=entry.getKey（）；
字符串值=entry.getValue（）；
System.out.println（键+“=>”+值）；
}
}
您可以收集第三个数组，其中包含这两个数组的元素对，并对其进行排序。然后可以迭代此数组并替换前两个数组的元素：

int[]city={3,1,5}；
int[]pop={33333333,33}；
int[][]排序=IntStream.range（0，city.length）
//溪流
.mapToObj（i->newint[]{city[i]，pop[i]}）
//按城市排序
.sorted（Comparator.comparing（arr->arr[0]））
.toArray（int[]]：：新建）；
//替换前两个阵列的元素
IntStream.range（0，sorted.length）.forEach（i->{
城市[i]=已排序[i][0]；
pop[i]=已排序的[i][1]；
});
System.out.println（Arrays.toString（city））；//[1, 3, 5]
System.out.println（Arrays.toString（pop））；//[33333, 333, 33]


另请参见：
因为它们是相关信息，所以最好将这两个信息存储在城市对象上。
City
类甚至可以实现
Comparable
。通过这种方式，您可以调用
集合。仅使用
城市的集合对
进行排序。
此外，在处理排序和集合时，您的对象还应该覆盖
equals（）
和
hashCode（）
方法。这将使每个对象真正独一无二。@Mr.Polywhill Yes。因为我认为这不是城市的“自然”排序，所以我更喜欢
比较器
方式。@polywhill先生，城市排序有很多种方式。我不确定按总体排序是否比按id排序更自然。这使得对特定排序使用比较器是一个很好的计划。我会称之为城市人口比较器。@AliSeyedi:id
s的顺序是否重要，如果两个城市的人口相等？
Collections.sort(cities, new CityPopulationComparator());

public final class ParallelIntArrays extends AbstractList<int[]> {

    private final int[] array1;
    private final int[] array2;

    public ParallelIntArrays(int[] array1, int[] array2) {
        if (array1.length != array2.length)
            throw new IllegalArgumentException();
        this.array1 = array1;
        this.array2 = array2;
    }

    @Override
    public int[] get(int i) {
        return new int[] { array1[i], array2[i] };
    }

    @Override
    public int size() {
        return array1.length;
    }

    @Override
    public int[] set(int i, int[] a) {
        if (a.length != 2)
            throw new IllegalArgumentException();
        int[] b = get(i);
        array1[i] = a[0];
        array2[i] = a[1];
        return b;
    }
}

int[] city = {5,   1,  2,    4,   3   };
int[] pop =  {100, 30, 4000, 400, 5000};
new ParallelIntArrays(city, pop).sort(Comparator.comparingInt(arr -> arr[0]));
System.out.println(Arrays.toString(city));
System.out.println(Arrays.toString(pop));