Java 使用Comparator对字符串列表进行排序

我有绳子。BOMResult：

1 | 00022954 | 41.418\n 2 | 00022951 | 1.0\n 3 | 00022945 | 41.575\n 3 | 00022944 | 41.684\n 3 | 00022944 | 41.778\n 3 | 00022944 | 41.871\n 3 | 00022946 | 42.918\n 3 | 00022944 | 41.918\n 3 | 00022944 | 41.825\n 3 | 00022944 | 41.731\n 3 | 00022945 | 41.621\n 3 | 00022953 | 41.512\n 4 | 00022957 | 0.0\n 5 | 00022947 | 42.809\n 5 | 00022942.918\n 5 | 00022948 | 43.918\n 5 | 00022947 | 42.871\n 5 | 00022950 | 42.746\n 4 | 00022952 | 1.0\n 5 | 00022941.246\n 5 | 00020472 | 41.184\n 2 | 00022958 | 0.0\n 3 | 00022945 | 39.621\n 3 | 00022944 | 39.731\n 3 | 00022944 | 39.84\n 3 | 00022944 | 39.949\n 3 | 00022944 | 39.887\n 3 | 00022944 | 39.793\n 3 | 00022945 | 39.684\n 3 | 00022956 | 39.512\n 4 | 00022959 | 1.0\n 5 | 00022941 | 40.762\n 5 | 00022943 | 40.699\n 4 | 00022957 | 0.0\n 5 | 00022947 | 42.809\n 5 | 00022942.918\n 5 | 00022948 | 43.918\n 5 | 00022947 | 42.871\n 5 | 00022950 | 42.746\n 3 | 00022949 | 40.996\n 3 | 00022944 | 39.996\n

当竖线（|）被分隔时

第一个字符串是level

最后一个字符串是排序的基础

如果级别相等，请对字符串进行排序

List<String> rowList = Arrays.asList(BOMResult.split("\n"));
Collections.sort(rowList, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        String array1[] = s1.split("\\|");
        String array2[] = s2.split("\\|");
        int i1 = Integer.parseInt(array1[0]);
        int i2 = Integer.parseInt(array2[0]);

        if (i1 == i2) {
            return Double.valueOf(array1[array1.length-1]).compareTo(Double.valueOf(array2[array2.length-1]));
        } else {
            return 0;
        }
    }
});
BOMResult = String.join("\n", rowList);

我希望在同一级别进行排序，即使行不同

预期结果：

1|00022954|41.418
2|00022958|0.0
3|00022956|39.512
3|00022945|39.621
3|00022945|39.684
3|00022944|39.731
3|00022944|39.793
3|00022944|39.84
3|00022944|39.887
3|00022944|39.949
4|00022957|0.0
4|00022959|1.0
5|00022943|40.699
5|00022941|40.762
5|00022950|42.746
5|00022947|42.809
5|00022947|42.871
5|00022942|42.918
5|00022948|43.918
3|00022944|39.996
3|00022949|40.996
2|00022951|1.0
3|00022953|41.512
3|00022945|41.575
3|00022945|41.621
3|00022944|41.684
3|00022944|41.731
3|00022944|41.778
3|00022944|41.825
3|00022944|41.871
3|00022944|41.918
3|00022946|42.918
4|00022957|0.0
5|00020472|41.184
5|00022941|41.246
5|00022950|42.746
5|00022947|42.809
5|00022947|42.871
5|00022942|42.918
5|00022948|43.918
4|00022952|1.0

---

首先为记录创建一个数据对象
（用实际属性替换名称，即

第一级

->

级别

）：

之后，您可以通过链接比较器对这些记录的列表进行排序。 示例（按第一、第二、第三顺序排序）：

List List=newlinkedlist（）；
增加（新数据（1，“00022954”，41.418））；
增加（新数据（2，“00022951”，1.0））；
增加（新数据（3，“00022953”，41.512））；
增加（新数据（3，“00022945”，41.575））；
增加（新数据（3，“00022945”，41.621））；
//洗牌以测试排序
集合。洗牌（列表）；
//对数据进行排序
集合。排序（列表，
Comparator.comparing（数据：：getFirst）
.thenComparing（数据：：getSecond）
.然后比较（数据：：getThird））；
//输出数据
list.forEach（System.out:：println）；

您可以在同一比较器中合并第一列和最后一列，如下所示：

Collections.sort(rowList, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        String array1[] = s1.split("\\|");
        String array2[] = s2.split("\\|");
        Integer i1 = Integer.valueOf(array1[0].trim());
        Integer i2 = Integer.valueOf(array2[0].trim());

        return i1.compareTo(i2) + Double.valueOf(array1[array1.length-1]).compareTo(Double.valueOf(array2[array2.length-1]));

    }
});

Collections.sort（行列表，新比较器（）{
@凌驾
公共整数比较（字符串s1、字符串s2）{
字符串数组1[]=s1.split（“\\\\”）；
字符串array2[]=s2.split（“\\\\”）；
Integer i1=Integer.valueOf（array1[0].trim（））；
整数i2=Integer.valueOf（array2[0].trim（））；
返回i1.compareTo（i2）+Double.valueOf（array1[array1.length-1]）。compareTo（Double.valueOf（array2[array2.length-1]）；
}
});

好的，然后尝试以下操作：

Collections.sort(rowList, new Comparator<String>() {
  @Override
  public int compare(String s1, String s2) {
    String array1[] = s1.split("\\|");
    String array2[] = s2.split("\\|");
    Integer i1 = Integer.valueOf(array1[0].trim());
    Integer i2 = Integer.valueOf(array2[0].trim());
    int res = i1.compareTo(i2);
    if (res == 0) {
      Double d1 = Double.valueOf(array1[array1.length - 1]);
      Double d2 = Double.valueOf(array2[array2.length - 1]);
      return d1.compareTo(d2);
    }
    return res;

  }
});

Collections.sort（行列表，新比较器（）{
@凌驾
公共整数比较（字符串s1、字符串s2）{
字符串数组1[]=s1.split（“\\\\”）；
字符串array2[]=s2.split（“\\\\”）；
Integer i1=Integer.valueOf（array1[0].trim（））；
整数i2=Integer.valueOf（array2[0].trim（））；
int res=i1。与（i2）相比；
如果（res==0）{
Double d1=Double.valueOf（array1[array1.length-1]）；
Double d2=Double.valueOf（array2[array2.length-1]）；
返回d1。比较（d2）；
}
返回res；
}
});

很抱歉，您的预期结果没有以任何方式排序？你的排序标准是什么？@DiabolicWords对不起，我修改了预期结果。我所要做的就是在同一级别进行排序，即使是在不同的行。在同一级别，0.0应先于0.1。（1 | 00022954 | 41.418，2 | 00022958 | 0.0，3 | 00022956 | 39.512，…，2 | 00022951 | 1.0，3 | 00022953 | 41.512…）谢谢你。谢谢你的回答。我修改了预期结果并添加了图像。字符串是与家长的子关系，不应按顺序更改。感谢您的回答。我修改了预期结果并添加了图像。字符串是与父母的子关系，不应按顺序更改。为什么这样做？你能解释一下代码吗？只有代码的答案通常没有多大帮助。

List<Data> list = new LinkedList<>();
list.add(new Data(1, "00022954", 41.418));
list.add(new Data(2, "00022951", 1.0));
list.add(new Data(3, "00022953", 41.512));
list.add(new Data(3, "00022945", 41.575));
list.add(new Data(3, "00022945", 41.621));

// shuffle to test sorting
Collections.shuffle(list);

// sort the data
Collections.sort(list, 
    Comparator.comparing(Data::getFirst)
        .thenComparing(Data::getSecond)
        .thenComparing(Data::getThird));

// output the data
list.forEach(System.out::println);

Collections.sort(rowList, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        String array1[] = s1.split("\\|");
        String array2[] = s2.split("\\|");
        Integer i1 = Integer.valueOf(array1[0].trim());
        Integer i2 = Integer.valueOf(array2[0].trim());

        return i1.compareTo(i2) + Double.valueOf(array1[array1.length-1]).compareTo(Double.valueOf(array2[array2.length-1]));

    }
});

Collections.sort(rowList, new Comparator<String>() {
  @Override
  public int compare(String s1, String s2) {
    String array1[] = s1.split("\\|");
    String array2[] = s2.split("\\|");
    Integer i1 = Integer.valueOf(array1[0].trim());
    Integer i2 = Integer.valueOf(array2[0].trim());
    int res = i1.compareTo(i2);
    if (res == 0) {
      Double d1 = Double.valueOf(array1[array1.length - 1]);
      Double d2 = Double.valueOf(array2[array2.length - 1]);
      return d1.compareTo(d2);
    }
    return res;

  }
});