按特定顺序对数据进行排序

Question

我的 rowId 如下所示

1

1.1

1.2

.

1.9

2

2.1

.

。 3 . . 9

.

9.9

10

10.1

List<MyBean> sortedList = rootItems.stream().sorted(Comparator.comparing(MyBean::getRowId)) .collect(Collectors.toList());

通过使用上面的代码，我得到如下输出。

1

10

11

12

2

2.1

2.2

.

.

但我想要如下输出

1

1.1

1.1.1

1.1.1.1

1.2

1.3

.

.

.

1.9

10

11

.

2

2.1

2.2

2.3

.

.

3

3.1

3.2

.

.

4

.

.

.

9

9.1

9.2

.

.

9.9

10

10.1

。

。

这样它需要继续

如果我想要这样，我需要使用哪个 Set

Answer 1

如果您在内部将这些字符串标准化为可以排序的格式，那么比较这些字符串会容易得多。我建议用零填充各个项目，如下所示：

private static final Pattern SINGLE_DIGIT = Pattern.compile("\\b(\\d)\\b");
...
String padWithZeroes = SINGLE_DIGIT.matcher(yourInputString).replaceAll("0$1");

现在只需对填充的字符串进行排序。 这是假设最高的数字是2位，如果不是，我们需要调整正则表达式，逻辑会稍微复杂一些。

---

如果任何数字段可以长于 2 位，那么它会变得更复杂。这是一种将所有段填充到最大长度的方法：

static String padWithZeroes(String yourInputString, int digits) {
    final Matcher matcher = SINGLE_DIGIT.matcher(yourInputString);
    StringBuffer sb = new StringBuffer();
    while(matcher.find()){

        matcher.appendReplacement(sb, pad(digits - matcher.group().length())+matcher.group());
    }
    matcher.appendTail(sb);
    return sb.toString();
}

static String pad(int length) {
    final char[] chars = new char[length];
    Arrays.fill(chars, '0');
    return new String(chars);
}

这里的问题是，您必须预先知道 digits 参数的值，因此您要么知道自己的数据，要么必须进行单独的迭代来测量最大长度。

Answer 2

我没有在我的电脑上尝试过，但似乎数据没有被转换成双倍进行比较。我认为在排序之前添加mapToDouble(i->i.getRowId) 可以解决您的问题。

Answer 3

正如我在评论中已经说过的，问题是字符串是逐个字符进行比较的。因此，您需要更改字符串以使每个元素具有相等的长度并且每个字符位置对应于其他 id 中的相同位置，或者将元素解析为数字序列

备选方案 1 的缺点是您需要为每个组件（即 a.b.c 中的 a、b、c 等）设置一个固定的最大长度，或者您必须先计算元素的数量。

因此，备选方案 2 似乎更好，但每次比较字符串时解析字符串可能会有点昂贵。因此，您可能想要引入一个代表您的 id 并保存实际 id 字符串以及已解析版本的类。该类可以实现Comparable 并仅在解析后的版本上运行。

例子：

class MyRowId implements Comparable<MyRowId> {
  private final String id;

  //when serializing instances of that class you might want to ignore this array 
  //and upon deserialization parse the string again
  private final int[] parsed;

  public MyRowId( String idString ) {
    id = idString;
    parsed = Arrays.stream( idString.split("\\.") ).mapToInt( Integer::parseInt ).toArray();
  }

  public int compareTo( MyRowId other )  {
    //Compare the elements one by one until we run out of elements or hit a difference
    //There might be a more Java8-ish way but I didn't find it yet
    for( int i = 0; i < Math.min( parsed.length, other.parsed.length ); i++ ) {
      int r = Integer.compare( parsed[i], other.parsed[i] );
      if( r != 0 ) {
        return r;
      }
    }

    //If we're here all compared elements were equal but one id might be longer so compare the lengths.
    //That would handle things like comparing "1.1" to "1.1.1" where the latter is greater.
    return Integer.compare( parsed.length, other.parsed.length );
  }
}

Answer 4

像这样使用自己的compare() 方法：

Collections.sort(myList, new Comparator<String>() {
    @Override
    public int compare(String id1, String id2) {
        double d1 = Double.parseDouble(id1);
        double d2 = Double.parseDouble(id2);
        return Double.compare(d1, d2);
    }
});

或者只是将 ID 解析/映射到双精度然后比较/排序。

Answer 5

如果您指定了 getRowId() 的返回类型，那么实现可能会有所不同。

---

您可能需要做的是为 MyBean 类定义一个 Comparator。它可以实现为

• 类
• 匿名类
• lambda 表达式。

你的情况可能是：

class MyBeanComparator implements Comparator<MyBean>{
  public static final MyBeanComparator INSTANCE = new MyBeanComparator();
  public int compare(MyBean b1, MyBean b2){
         //your custom rules
      }
}

然后

List<MyBean> sortedList = rootItems.stream().sorted(MyBeanComparator.INSTANCE::compare) .collect(Collectors.toList());