基于另一个数组的排序[重复]

Question

我有一个字符串数组列表totalVals。 totalVals 中的每个条目都是一个字符串 name 和一个双精度 loc 在插入数组列表之前连接成一个字符串，例如：

totalVals.add(name + "," + loc);

这就是我获得数据的方式。我已将这些值分成一个字符串和双精度数组，如下所示：

String[] temp;
String[] names = new String[totalVals.size()];
double[] locs = new double[totalVals.size()];

for (int i = 0; i < totalVals.size(); I++){
    temp = totalVals.get(i).splot(",");
    names[i] = temp[0];
    locs[i] = Double.parseDouble(temp[1]);
}

但是，现在我想对数据进行排序并在返回之前将其放回数组列表中。我希望locs 数据按降序排列，我可以使用Arrays.sort(locs, Collections.reverseOrder()); 来做到这一点。但我不知道如何对 names 进行排序，以便名称仍然与它们原来的位置相关联。

totalVals 示例：{"Bahamas,32.2233","Zimbabwe,82.2443","India,56.2355","Australia,24.4363"}

将分为：

names = {"Bahamas","Zimbabwe","India","Australia"};
locs = {32.2233,82.2443,56.2355,24.4363};

然后将被排序到：

names = {"Zimbabwe","India","Bahamas","Australia"};
locs = {82.2443,56.2355,32.2233,24.4363};

那么我将如何对两个数组进行排序，以使两个数组中索引 i 处的关联保持不变？

Answer 1

不要把你的数组变成两个数组，而是把它变成ArrayList<Pair>

Pair 类如下：

public class Pair {
    private String country;
    private int loc;

    public Pair(String country, int loc) {
        this.country = country;
        this.loc = loc;
    }

    // getters and setters here
}

然后像这样对数组进行排序：

Collections.sort(array, Comparator.comparingInt(Pair::getLoc));

然后将你的数组拆分成两个数组。

Answer 2

不是将arraylist分成两个不同的数组并分别排序，而是将ArrayList基于double值降序排序，然后将arraylist分成两个数组

 List<String> list = new ArrayList<>();
    list.add("Bahamas,32.2233");
    list.add("Zimbabwe,82.2443");
    list.add("India,56.2355");
    list.add("Australia,24.4363");

   List<String> result = list.stream().sorted((a,b)->b.substring(b.lastIndexOf(",")+1).compareTo(a.substring(a.lastIndexOf(",")+1))).collect(Collectors.toList());

 System.out.println(result);  //[Zimbabwe,82.2443, India,56.2355, Bahamas,32.2233, Australia,24.4363]

将列表分解为 double[] 数组和 String[] 数组

double[] arr = result.stream().mapToDouble(i->Double.parseDouble(i.substring(i.lastIndexOf(",")+1))).toArray();
   System.out.println(Arrays.toString(arr)); // [82.2443, 56.2355, 32.2233, 24.4363]

String[] countries = result.stream().map(i->i.substring(0, i.lastIndexOf(","))).toArray(String[]::new);
   System.out.println(Arrays.toString(countries)); //[Zimbabwe, India, Bahamas, Australia]

Java 8 之前的版本

通过使用带有自定义比较器的`Collections.sort()，然后将列表拆分为两个不同的数组

 Collections.sort(list, new Comparator<String>() {

    @Override
    public int compare(String o1, String o2) {

        return o2.substring(o2.lastIndexOf(",")+1).compareTo(o1.substring(o1.lastIndexOf(",")+1));
    }
});
 System.out.println(list); //[Zimbabwe,82.2443, India,56.2355, Bahamas,32.2233, Australia,24.4363]

Answer 3

TheWildHealer 的解决方案简洁而优雅。下面是针对旧 Java 平台的类似解决方案，以及用于测试的 main() 方法：

import java.util.ArrayList;
import java.util.Collections;

public class LocCountry implements Comparable {

    private double loc;
    private String country;

    public LocCountry(String country, double loc) {
        this.loc = loc;
        this.country= country;
    }

    public double getLoc() {return loc;}
    public String getCountry() {return country;}

    public String toString() { return country + " - " + loc;}
    public int compareTo(Object obj2) {
        double loc1 = this.getLoc();
        double loc2 = ((LocCountry)obj2).getLoc();

        if (loc1 > loc2) return 1;
        if (loc1 < loc2) return -1;
        return 0;
    }


    public static void main(String args[]) {
        ArrayList lcs = new ArrayList();

        lcs.add(new LocCountry("Bahamas"   , 82.2443));
        lcs.add(new LocCountry("Zimbabwe"  , 56.2355));
        lcs.add(new LocCountry("India"     , 32.2233));
        lcs.add(new LocCountry("Australia" , 24.4363));
        Collections.sort(lcs);
        Collections.reverse(lcs);

        for (int i = 0; i < lcs.size(); i++){
            System.out.println(lcs.get(i).toString());
        }
    }
}

结果：

Bahamas - 82.2443
Zimbabwe - 56.2355
India - 32.2233
Australia - 24.4363

Answer 4

提供的方法TheWildHealer 肯定比这更干净，但这里有一个不需要自定义类的解决方案。流式传输数组并将其映射到数组/[String, Integer] 对。根据第二个值/整数排序，然后重构为字符串。

Arrays.stream(totalVals)
    .map(s -> s.split(","))
    .map(ss -> new Object[] {ss[0], Integer.parseInt(ss[1])})
    .sorted(Comparator.comparingInt(ss -> (Integer) ss[1]))
    .map(ss -> ss[0] + "," + ss[1])
    .toArray(String[]::new);