将 allMatch、noneMatch 和 anyMatch 组合在一个流上

Question

我想要以下逻辑：（我知道它不起作用，因为它不止一次地消耗流）。但我不确定如何实现它。

Stream<ByteBuffer> buffers = super.getBuffers().stream();
if (buffers.allMatch(b -> b.position() > 0)) {
    return OutgoingMessageStatus.FULLY_SENT;
} else if (buffers.noneMatch(b -> b.position() > 0)) {
    return OutgoingMessageStatus.WAS_NOT_SENT;
} else {
    return OutgoingMessageStatus.PARTIALLY_SENT;
}

我该怎么做？

Answer 1

由于super.getBuffers() 的结果是List<ByteBuffer>，你可以迭代两次。

List<ByteBuffer> buffers = super.getBuffers();
if (buffers.stream().allMatch(b -> b.position() > 0)) {
    return OutgoingMessageStatus.FULLY_SENT;
} else if (buffers.stream().noneMatch(b -> b.position() > 0)) {
    return OutgoingMessageStatus.WAS_NOT_SENT;
} else {
    return OutgoingMessageStatus.PARTIALLY_SENT;
}

请注意，这仍然不需要在所有情况下遍历所有元素。 allMatch 在遇到不匹配的元素时立即返回，noneMatch 在遇到匹配的元素时立即返回。所以在PARTIALLY_SENT的情况下，有可能不看所有元素就得出结论。

另一种选择是

List<ByteBuffer> buffers = super.getBuffers();
if(buffers.isEmpty()) return OutgoingMessageStatus.FULLY_SENT;
Predicate<ByteBuffer> p = b -> b.position() > 0;
boolean sent = p.test(buffers.get(0));
if(!sent) p = p.negate();
return buffers.stream().skip(1).allMatch(p)? sent?
    OutgoingMessageStatus.FULLY_SENT:
    OutgoingMessageStatus.WAS_NOT_SENT:
    OutgoingMessageStatus.PARTIALLY_SENT;
}

第一个元素的状态决定了我们必须检查的条件。只要有一个矛盾的元素，allMatch 立即返回，我们有一个PARTIALLY_SENT 的情况。否则，所有元素都像第一个一样匹配，这意味着“全部发送”或“未发送”。

空列表的预检查产生与原始代码相同的行为，并确保get(0) 永不中断。

---

如果您确实有一个 Stream 而不是可以多次迭代的源，则没有简单的捷径解决方案，因为这需要有状态的谓词。但是，有一些简单的解决方案可以处理所有元素。

Map<Boolean,Long> result=getBuffers().stream()
    .collect(Collectors.partitioningBy(b -> b.position() > 0, Collectors.counting()));
return
    result.getOrDefault(false, 0L)==0?
        OutgoingMessageStatus.FULLY_SENT:
    result.getOrDefault(true, 0L)==0?
        OutgoingMessageStatus.WAS_NOT_SENT:
        OutgoingMessageStatus.PARTIALLY_SENT;

或

return super.getBuffers().stream()
    .map(b -> b.position() > 0?
              OutgoingMessageStatus.FULLY_SENT: OutgoingMessageStatus.WAS_NOT_SENT)
    .reduce((a,b) -> a==b? a: OutgoingMessageStatus.PARTIALLY_SENT)
    .orElse(OutgoingMessageStatus.FULLY_SENT);

Answer 2

你可以使用filter()，然后统计通过它的元素个数：

Stream<ByteBuffer> buffers = super.getBuffers().stream();
int matches = buffers.filter(b -> b.position() > 0).count();
if (matches == super.getBuffers().size()) {
    return OutgoingMessageStatus.FULLY_SENT;
} else if (matches == 0) {
    return OutgoingMessageStatus.WAS_NOT_SENT;
} else {
    return OutgoingMessageStatus.PARTIALLY_SENT;
}

这里假设Stream (super.getBuffers()) 的数据源有一个size() 方法。如果没有，您可以使用附加变量计算ByteBuffers 的总数（我知道不太优雅）：

int[] total = {0};
int matches = buffers.filter(b -> {total[0]++; return b.position() > 0;}).count();
if (matches == total[0]) {
    return OutgoingMessageStatus.FULLY_SENT;
} else if (matches == 0) {
    return OutgoingMessageStatus.WAS_NOT_SENT;
} else {
    return OutgoingMessageStatus.PARTIALLY_SENT;
}

这种方法的缺点是当只有一些元素通过过滤器时它不会很快失败（即输出应该是OutgoingMessageStatus.PARTIALLY_SENT）。也许您可以使用一些reduce 操作来返回三个可能的输出之一，并且只处理必要的元素。

Answer 3

你需要一个集合来重用它。

您可以使用count() 代替collect(toList())，具体取决于您是否需要结果。

List<ByteBuffer> list = super.getBuffers();
List<ByteBuffer> buffers = list.stream().filter(b -> b.position() > 0).collect(toList());
if (buffers.size() == list.size()) {
    return OutgoingMessageStatus.FULLY_SENT;
} else if (buffers.isEmpty()) {
    return OutgoingMessageStatus.WAS_NOT_SENT;
} else {
    return OutgoingMessageStatus.PARTIALLY_SENT;
}

Answer 4

我只是想用不同的类型和谓词解决你刚才遇到的同一个问题。没有找到任何令人满意的答案，所以我以这种方式实现了自己：

Enum 不仅包含true 和false 来满足谓词，还包含NONE（用于空集合）和ENTANGLED（表示集合的某些元素满足谓词和有些没有）：

public enum QuantumBoolean {
    NONE, TRUE, FALSE, ENTANGLED;

    public static QuantumBoolean fromBoolean(boolean bool) {
        if (bool) return QuantumBoolean.TRUE;
        return QuantumBoolean.FALSE;
    }
}

为了利用 Java Stream API 并在我需要使用特定参数调用 .reduce() 时迭代集合，因此我将它们打包到新类中：

public class QuantumBooleanReducer<T> {

    private final Predicate<T> predicate;
    public static final QuantumBoolean IDENTITY = QuantumBoolean.NONE;

    public QuantumBooleanReducer(Predicate<T> predicate) {
        this.predicate = predicate;
    }

    public final QuantumBoolean accumulator(QuantumBoolean state, T element) {
        QuantumBoolean newState = QuantumBoolean.fromBoolean(predicate.test(element));
        if (QuantumBoolean.NONE.equals(state))
            return newState;
        if (newState.equals(state))
            return state;
        return QuantumBoolean.ENTANGLED;
    }

    public static QuantumBoolean combiner(QuantumBoolean state1, QuantumBoolean state2) {
        if (state1.equals(state2))
            return state1;
        if (QuantumBoolean.NONE.equals(state1))
            return state2;
        if (QuantumBoolean.NONE.equals(state2))
            return state1;
        return QuantumBoolean.ENTANGLED;
    }
}

然后你可以通过调用类似的方法来解决你的问题：

switch(buffers.stream()
              .reduce(QuantumBooleanReducer.IDENTITY,
                      new QuantumBooleanReducer<ByteBuffer>(buffer -> buffer.position() > 0)::accumulator,
                      QuantumBooleanReducer::combiner)) {
            case FALSE:
                return OutgoingMessageStatus.WAS_NOT_SENT;
            case TRUE:
                return OutgoingMessageStatus.FULLY_SENT;
            case ENTANGLED:
                return OutgoingMessageStatus.PARTIALLY_SENT;
            default:
                throw new IllegalStateException("Unexpected Quantum Boolean");
}