字符串中带下划线的降序排序

Question

我正在尝试对字符串中包含下划线的列执行降序排序。这是我的降序排序方法。

protected void validateDescendingOrder(Integer column) {
    // create a column list
    List<String> columnList = getColumnList(column);

    // create a new list and sort
    List<String> sortedcolumnList = new ArrayList<String>();
    sortedcolumnList.addAll(columnList);
    Collections.sort(sortedcolumnList, new Comparator<String>() {
    public int compare(String o1, String o2) {
        if (o1.contains("_") && o2.contains("_")) {
            return compare(o1.substring(1), o2.substring(1));
        }

        if (o1.contains("_")) {
            return 1;
        }
        if (o2.contains("_")) {
            return -1;
        }

        return o1.compareTo(o2);
    }
});

// sort the list using the custom comparator
Collections.sort(sortedcolumnList, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));
//sortedcolumnList.sort(customComparator);
System.out.println(sortedcolumnList);
System.out.println(columnList);
    
// compare the original list order with the sorted list to make sure they match
assertEquals(sortedcolumnList, columnList);

我期待着我的同类回归 Test_jenn、Test_Community、TestRelease、TestCom1、test1，但它正在返回 TestRelease、TestCom1、Test_jenn、Test_Community、test1

Answer 1

问题

Collections.sort()

被调用两次，并且由于调用

Collections.sort()

确实对列表进行了重新排序，因此之前的排序（几乎）被忽略。 发布的代码基本上是：

Collections.sort(list, comparator1);
Collections.sort(list, comparator2);

因此，结果顺序是比较器 2 给出的顺序 - 

reverseOrder(CASE_INSENSITIVE_ORDER)

。

compartor1（使用下划线的匿名类）的排序被

忽略
！ 也就是说，做类似的事情：

Collections.sort(list, Collections.reverseOrder(comparator3));

是否

不

反转列表之前的顺序；它确实使用给定的 comparator3 以相反的顺序进行排序。在发布的代码中，被反转的比较器是

String.CASE_INSENSITIVE_ORDER

，因此列表最终按字符串的降序（不区分大小写）排序。解决方案

删除

第二个排序 Collections.sort(sortedcolumnList, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));`

反转匿名比较器的替代方案：

使用

Collections#reverseOrder

Collections.reverseOrder( new Comparator<String>() {
    public int compare(String o1, String o2) {
        if (o1.contains("_") && o2.contains("_")) {
            return compare(o21.substring(1), o2.substring(1));
        }

        if (o2.contains("_")) {
            return 1;
        }
        if (o1.contains("_")) {
            return -1;
        }

        return o2.compareTo(o1);
    }
} )

只需交换

compare

3.  的参数
   注意：不要交换递归调用的参数！

   
   

new Comparator<String>() {
    public int compare(String o1, String o2) {
        if (o1.contains("_") && o2.contains("_")) {
            return compare(o21.substring(1), o2.substring(1));
        }

        if (o2.contains("_")) {
            return 1;
        }
        if (o1.contains("_")) {
            return -1;
        }

        return o2.compareTo(o1);
    }
}

或反转结果

注意：不要反转递归调用的结果！
4. 
   

new Comparator<String>() {
    public int compare(String o1, String o2) {
        if (o1.contains("_") && o2.contains("_")) {
            return compare(o1.substring(1), o2.substring(1));
        }

        if (o1.contains("_")) {
            return -1;
        }
        if (o2.contains("_")) {
            return 1;
        }

        return - o1.compareTo(o2);
    }
}

注意

我不确定

compare

的递归调用的意图是什么。对我来说，这似乎是一种昂贵且容易出错的方法，可以忽略两个字符串下划线之前的所有内容。

compare

方法最终可以被调用来将每个元素与其他元素进行比较，也就是说，它可以被经常调用，更能说明非递归解决方案。建议：不要使用

contains

来搜索下划线，使用

indexOf()

来忽略该索引之前的所有内容。正如我所写，不确定确切的要求是什么
1

-

---

substring()

“保证稳定：相等的元素不会因排序而重新排序。”(javadoc

)