您可以使用另一种可能的解决方案。看起来像
python zip 功能。

public class ComparisonString {
    private static List<String> input;

    public static void main(String[] args) {
        input = Arrays.asList("TRUE", "FALSE", "TRUE", "N/A");
        ComparisonString cs = new ComparisonString();
        System.out.println(cs.getMatchedOutput(Arrays.asList("TRUE", "N/A", "N/A", "FALSE")));
    }

    public Optional<String> getMatchedOutput(final List<String> givenInput) {
        boolean notFlag = IntStream.range(0, input.size())

                // zip to new object
                .mapToObj(i -> new Pair<>(input.get(i), givenInput.get(i)))

                // stop when the false flag is found
                .anyMatch(p -> {
                    String inputValue = p.getKey();
                    String givenValue = p.getValue();

                    return inputValue != null
                            && !("N/A".equalsIgnoreCase(inputValue) || "N/A".equalsIgnoreCase(givenValue))
                            && !inputValue.equalsIgnoreCase(givenValue);    // true breaks the stream
                });
        if (!notFlag) {
            return Optional.of("flag = true");
        } else {
            return Optional.empty();
        }
    }
}

输出

Optional[flag = true]

可以使用 IntStream 要为两个列表生成索引流，请过滤掉不相关的列表值并匹配其余的值：

public Optional<String> getMatchedOutput(final List<String> givenInput) {
    return IntStream.range(0, givenInput.size())
             .filter(i -> null != input.get(i) && null != givenInput.get(i))
             .filter(i -> !"N/A".equalsIgnoreCase(input.get(i)) && !"N/A".equalsIgnoreCase(givenInput.get(i)))
             .allMatch(i -> input.get(i).equalsIgnoreCase(givenInput.get(i)))
        ? Optional.of("flag = true")
        : Optional.empty();
}

测试已知数据：

input = Arrays.asList("TRUE","FALSE","TRUE","N/A");
ComparisonString cs = new ComparisonString();
 System.out.println(cs.getMatchedOutput(Arrays.asList("TRUE","N/A","N/A","FALSE")));

印刷品：

Optional[flag = true]

不幸的是，不能使用流同时处理两个列表。你能做的就是使用迭代器。我试过写一些代码，应该是这样的：

public static void streamTest(List<String> givenList)
    {
        List<String> testing = new ArrayList<>();
        IntStream.range(0, givenList.size())
                .parallel()
                .forEach(i -> {
                    if (input.get(i) != null&& !(input.get(i).equalsIgnoreCase("N/A") || givenList.get(i).equalsIgnoreCase("N/A"))
                            && !input.get(i).equalsIgnoreCase(givenList.get(i)))
                        testing.add("false");
                });
        if (testing.isEmpty())
            System.out.println("flag = true");
        else
            System.out.println("flag = false");
    }

我希望这对你有帮助，给你一个开始。

你做这件事的方式没有任何问题，而且streams在这方面做得过火了，而且效率可能更低。不过，我有两个建议：
不需要布尔值。只是 return Optional.empty() 在一次失败的比较之后。否则， return Optional.of("flag = true") 在for循环之后。
你应该检查一下是否有不平等的行为 List 尺寸。如果为循环选择较长的循环，它可能会引发异常。你可以选择 Math.min 在这两种大小中，忽略比较中的额外元素，或者只检查列表大小是否相等，并确定这对于应用程序的列表相等意味着什么。