Comparator.compareBoolean()与Comparator.compare()相同？

Question

我怎么写这个？

Comparator <Item> sort = (i1, i2) -> Boolean.compare(i2.isOpen(), i1.isOpen());

(代码不起作用)：

Comparator<Item> sort = Comparator.comparing(Item::isOpen).reversed();

比较方法没有类似于Comparator.comparingBool()的东西。Comparator.comparing返回int而不是"Item“。

Answer 1

你为什么不能这样写？

 Comparator<Item> sort = Comparator.comparing(Item::isOpen);

在Boolean.compareTo下面调用，这反过来又与Boolean.compare相同

public static int compare(boolean x, boolean y) {
    return (x == y) ? 0 : (x ? 1 : -1);
}

这一点：Comparator.comparing returns int and not "Item".没有什么意义，Comparator.comparing必须返回一个Comparator<T>；在您的情况下，它正确地返回一个Comparator<Item>。

Answer 2

重载comparingInt、comparingLong和comparingDouble仅出于性能原因。它们在语义上与非专用的comparing方法相同，因此使用comparing而不是comparingXXX具有相同的结果，但可能有装箱开销，但实际含义取决于特定的执行环境。

在boolean值的情况下，我们可以预测开销是可以忽略不计的，因为Boolean.valueOf方法总是返回Boolean.TRUE或Boolean.FALSE，并且永远不会创建新实例，因此即使某个特定的JVM无法内联整个代码，它也不依赖于优化器中存在的Escape分析。

正如您已经知道的，反转比较器是通过在内部交换参数来实现的，就像在lambda表达式中手动进行的那样。

请注意，仍然可以在不重复isOpen()表达式的情况下创建一个融合反转和非装箱比较的比较器：

Comparator<Item> sort = Comparator.comparingInt(i -> i.isOpen()? 0: 1);

但是，如前所述，它不太可能比Comparator.comparing(Item::isOpen).reversed()方法有更高的性能。

但是请注意，如果您有一个boolean排序条件，并且考虑到最大的性能，您可以考虑用一个桶排序变量来替换通用排序算法。例如。

如果您有一个流，替换

List<Item> result = /* stream of Item */
    .sorted(Comparator.comparing(Item::isOpen).reversed())
    .collect(Collectors.toList());

使用

Map<Boolean,List<Item>> map = /* stream of Item */
    .collect(Collectors.partitioningBy(Item::isOpen,
                                       Collectors.toCollection(ArrayList::new)));
List<Item> result = map.get(true);
result.addAll(map.get(false));

或者，如果您有一个List，则替换

list.sort(Comparator.comparing(Item::isOpen).reversed());

使用

ArrayList<Item> temp = new ArrayList<>(list.size());
list.removeIf(item -> !item.isOpen() && temp.add(item));
list.addAll(temp);

等。

Answer 3

使用键提取器参数进行比较：

Comparator<Item> comparator = 
    Comparator.comparing(Item::isOpen, Boolean::compare).reversed();