Java 使用Stream#takeWhile应用模式#astMatchPredicate

我尝试将模式的预测应用于字符串流：

final var someString = "first\nsecond\nthird"
final var myPattern  = java.util.regex.Pattern.compile("second");
final var sb         = new java.lang.StringBuilder();

someString.lines()
  .takeWhile(not(myPattern::asMatchPredicate))
  .forEachOrdered(sb::append)
  ;

但编译器拒绝了此操作，并出现以下错误：

 method asMatchPredicate in class java.util.regex.Pattern cannot be applied to given types
  required: no arguments
  found: java.lang.String
  reason: actual and formal argument lists differ in length

---

但是为什么呢？谓词接受一个字符串（

predicate

），而

takeWhile

方法需要一个

谓词另一种方法是通过对正则表达式模式求反，即使用
^（（？！second）。*$
作为正则表达式模式

演示：

class Main {
    public static void main(String[] args) {
        final var someString = "first\nsecond\nthird";
        final var myPattern = java.util.regex.Pattern.compile("^((?!second).)*$");
        final var sb = new java.lang.StringBuilder();

        someString.lines().takeWhile(myPattern.asPredicate()).forEachOrdered(sb::append);
        System.out.println(sb);
    }
}

first

输出：

class Main {
    public static void main(String[] args) {
        final var someString = "first\nsecond\nthird";
        final var myPattern = java.util.regex.Pattern.compile("^((?!second).)*$");
        final var sb = new java.lang.StringBuilder();

        someString.lines().takeWhile(myPattern.asPredicate()).forEachOrdered(sb::append);
        System.out.println(sb);
    }
}

first

正则表达式的解释如下：

class Main {
    public static void main(String[] args) {
        final var someString = "first\nsecond\nthird";
        final var myPattern = java.util.regex.Pattern.compile("^((?!second).)*$");
        final var sb = new java.lang.StringBuilder();

        someString.lines().takeWhile(myPattern.asPredicate()).forEachOrdered(sb::append);
        System.out.println(sb);
    }
}

first

实际上，您正在执行以下操作：

Predicate-Predicate=myMatcher:：asMatchPredicate；

方法引用意味着您试图实现自己的
谓词
，而不是使用
模式#asMatchPredicate（）
返回的谓词。这在这种情况下不起作用，原因有二：

Pattern#asMatchPredicate（）
方法不接受任何参数，但
Predicate#test（T）
方法只接受一个参数
Pattern#asMatchPredicate（）
方法返回一个
谓词
，而
谓词#test（T）
方法返回一个
布尔值
由于
模式#asMatchPredicate（）
方法已经返回了一个
谓词
，因此没有理由在这里使用方法引用，只需对返回的值求反即可。换句话说，您可以执行以下任一操作：

.takeWhile（Predicate.not（myMatcher.asMatchPredicate（）））

或：

.takeWhile（myMatcher.asMatchPredicate（）.negate（））
试试
.takeWhile（而不是（myPattern.asMatchPredicate（））
。结果是
第一秒第三秒。