集合排序意外行为

Question

集合排序没有给我预期的结果，还是我误读了方法？

要排序的 Row 对象列表：

public class Row {

    private int id;
    private boolean line;

    public Row(int id, boolean line) {
        this.id = id;
        this.line = line;
    }

    public boolean isLine() {
        return line;
    }

    @Override public String toString() {
        return "Row{" + "id=" + id + ", line=" + line + '}';
    }
}

起始数据：

[Row{id=0, line=true}, Row{id=1, line=false}, Row{id=2, line=true}, Row{id=3, line=false}]

排序代码：

    Collections.sort(rows, new Comparator<Row>(){
        @Override public int compare(Row o1, Row o2) {
            if (!o1.isLine() && !o2.isLine()) return 0;
            if (o1.isLine()) {
                    return 1;
            } else {
                    return -1;
            }
        }
    });

结果：

[Row{id=1, line=false}, Row{id=3, line=false}, Row{id=0, line=true}, Row{id=2, line=true}]

我的印象是所有带有line=true 的对象都应该在列表的开头，而不是结尾。

如果我稍微改变 Comporator 的实现：

    Collections.sort(rows, new Comparator<Row>(){
        @Override public int compare(Row o1, Row o2) {
            if (!o1.isLine() && !o2.isLine()) return 0;
            if (o1.isLine()) {
                return -1;
            } else {
                return 1;
            }
        }
    });

结果：

[Row{id=2, line=true}, Row{id=0, line=true}, Row{id=1, line=false}, Row{id=3, line=false}]

现在可以在列表的开头找到所有带有line=true 的对象，但它们已经交换了位置（id=0 应该是第一个）。

预期的排序结果：

[Row{id=0, line=true}, Row{id=2, line=true}, Row{id=1, line=false}, Row{id=3, line=false}]

Answer 1

我的印象是所有带有 line=true 的对象都应该在 列表的开头，而不是结尾。

不像这段代码：

  if (o1.isLine()) {
       return 1;
  } 

表示o1优于o2。
因此，isLine=true 的对象将发生在末尾，因为默认顺序是升序。

所有 line=true 的对象都可以在列表的开头找到 现在，但他们已经交换了位置（id=0 应该是第一个）。

您永远不会在比较器实现中使用id。
绝对不能考虑。

获取：

[行{id=0，行=真}，行{id=2，行=真}，行{id=1，行=假}， 行{id=3, line=false}]

您应该在Row 中添加一个getter 来检索id。 那么您应该首先按line=true 和id ASC 排序。

 Collections.sort(rows, new Comparator<Row>(){
    @Override public int compare(Row o1, Row o2) {
        if (!o1.isLine() && !o2.isLine()) return 0;
        if (o1.isLine() && o2.isLine()) {
            return o1.getId() > o2.getId();
        }
        if (o1.isLine()) {
            return -1;
        } else {
            return 1;
        }
    }
 });

更简洁的编写方法是使用 Java 8 Comparator：

Comparator<Row> comparatorRow = Comparator.comparing(Row::isLine).reversed()
                                          .thenComparing(Row::getId);

---

由于行已按 id 排序，并且排序保证稳定：排序结果不会重新排序相等的元素，您只能在 isLine 上进行比较：

Comparator<Row> comparatorRow = Comparator.comparing(Row::isLine).reversed();

Answer 2

您的比较不是对称的，因此被破坏了。使用在 Boolean 类中实现的反向比较（请注意 lambda 正文开头的 minus）：

Collections.sort(rows, (o1, o2) -> -Boolean.valueOf(o1.isLine()).compareTo(o2.isLine()));

Answer 3

总结@Dukeling：

    Collections.sort(rows, new Comparator<Row>(){
        @Override public int compare(Row o1, Row o2) {
            return -Boolean.compare(o1.isLine(), o2.isLine());
        }
    });

这给出了预期的结果。

输入：

[Row{id=0, line=true}, Row{id=1, line=false}, Row{id=2, line=true}, Row{id=3, line=false}]

结果：

[Row{id=0, line=true}, Row{id=2, line=true}, Row{id=1, line=false}, Row{id=3, line=false}]