Java 8 使用流重写复杂的 for 循环

Question

是否可以仅使用 java 8 流重写像这样的复杂 for 循环？我想出的任何东西似乎都比较臃肿，然后只保留下面的代码并使用正常的 for 循环。

public static  boolean isBalanced(String text) {
    int count = 0;
    for(int i = 0; i < text.length(); i++ ) {
        if (text.charAt(i) == ')') {
            count--;
        } else if (text.charAt(i) == '(') {
            count++;
        }
        if (count < 0) {
            return false;
        }
    }
    return count == 0;
}

使用流

public static boolean isBalanced2(String text) {
    AtomicInteger count = new AtomicInteger(0);

    text.chars()
        .forEachOrdered(x -> {
             if (x == ')') {
                 count.getAndDecrement();
             } else if (x == '(') {
                 count.getAndIncrement();
             }
        });

    return count.get() == 0;
}

它工作正常，但它会遍历整个字符串，有时这可能会浪费计算，例如在字符串“)......”的情况下

似乎不可能在 count

谢谢

Answer 1

这是与您使用 Java 8 的类似解决方案。

首先将'('、')' 和其他字符分别映射到1、-1 和0。然后计算一个累积和并检查每个部分和ps >= 0 和最终和s == 0。通过使用allMatch 进行部分和检查，该过程是短路的。

public static boolean isBalanced(String text) {
    AtomicInteger s = new AtomicInteger();
    return text.chars()
            .map(ch -> (ch == '(') ? 1 : (ch == ')') ? -1 : 0)
            .map(s::addAndGet)
            .allMatch(ps -> ps >= 0) && s.get() == 0;
}

这是一个支持多个不同括号的解决方案（需要一些IntStack 实现）：

IntStack stack = ...;
return text.chars()
        .map("(){}[]"::indexOf)
        .filter(i -> i >= 0)
        .allMatch(i -> {
            int form = i / 2; // 0 = (), 1 = {}, 2 = []
            int side = i % 2; // 0 = left, 1 = right
            if (side == 0) {
                stack.push(form);
                return true;
            } else {
                return stack.size() != 0 && stack.pop() == form;
            }
        }) && stack.size() == 0;

Answer 2

首先，我想提一下涉及副作用的代码通常不适用于流，仅出于这个原因，我建议继续使用命令式方法：

1. 代码短路
2. 书面可读

至于：

它工作正常，但有时会遍历整个字符串 例如在字符串的情况下可能会浪费计算

任何使您展示的流解决方案短路的尝试都将涉及side-effects，通常不鼓励这样做。

行为参数对流操作的副作用是，在 一般，气馁，因为它们通常会导致不知情的违规行为 无状态要求，以及其他线程安全 危害。如果行为参数确实有副作用，除非 明确指出，不保证可见性 这些对其他线程的副作用，也没有任何保证 对同一流中“相同”元素的不同操作 管道在同一个线程中执行。

结论是流并不总是解决所有问题，而是针对特定情况，这种情况绝对不是流友好的。

Answer 3

您可以从支持它的终端操作之一提前终止流评估。这些结果相对较少，但如果您愿意容忍一些轻微的滥用，并且您使用的是 Java 9 或更高版本，那么您可以使用takeWhile() 来非常普遍地执行提前终止。诀窍（也是滥用）是使用状态保留谓词。例如：

public static boolean isBalanced(String text) {
    final int[] state = new int[0];

    text.chars().takeWhile(c -> {
        if (c == '(') state[0]++; if (c == ')') state[0]--; return state[0] >= 0; 
    });

    return state[0] == 0;
}

这与您的原始循环非常相似。

Answer 4

下面的代码会做你想做的事，并且比你的原始代码小，但它是复杂的并且总是处理所有字符，即如果检测到不平衡的)，它不会提前停止。

但是，与此处的其他一些答案不同，它不会通过在流之外维护状态来违反流规则。

private static boolean isBalanced(String text) {
    return 0 == text.chars()
            .reduce(0, (n, c) -> n < 0 ? n : c == '(' ? n + 1 : c == ')' ? n - 1 : n);
}

逻辑如下：

• 保持代表嵌套级别的运行总计，即找到( 时增加值，找到) 时减少值。

• 如果总数低于 0，则停止更新，即当发现不平衡的 ) 时，将最终总数保持在 -1。

reduce 操作的结果是：

• 0：所有(都平衡)

• -1：发现不平衡)

• >0：发现不平衡(

相同代码的长版本，使用if 语句而不是条件三元运算符。

private static boolean isBalanced(String text) {
    int finalLevel = text.chars().reduce(0, (lvl, ch) -> {
        if (lvl < 0)
            return lvl; // Keep result of -1 for unbalanced ')'
        if (ch == '(')
            return lvl + 1;
        if (ch == ')')
            return lvl - 1;
        return lvl;
    });
    return (finalLevel == 0);
}

Answer 5

你不应该。

Lambda 和 Stream 不能替代所有复杂的 for 循环。虽然您可以使用Stream，但这并不意味着它对眼睛更好（什么更容易理解？）和性能（由于AtomicInteger 与int，您肯定会丢失一些东西基于操作，但您可能可以使用 int[] 数组代替）。

• 你不能尽快退出循环，除非你使用异常，但是你可以稍微缩小你的测试范围（你应该把它放平）。您可能会考虑在map 操作之后使用filter，但这不会使其更易于阅读。
• 您可能应该坚持使用pure function，例如：您可能不应该有副作用（在AtomicInteger 上）。

Answer 6

流确实有提前终止的概念，但前提是终端操作确实支持它。

根据您描述的操作，forEachOrdered 将遍历流中的 每个 元素，并且它没有能力提前中断。请记住：流可能是无限的，因此在对每个流进行排序时提前中断流可能被视为运行时错误。

本质上，我实际上鼓励您坚持使用循环变体而不是流变体，因为循环变体使您能够提前终止。考虑到它必须处理的约束条件，您为流变体编写的内容实际上是合理的。