从字符串java 8获取不匹配的部分

我的字符串为“我是Java新手（*）”

我的实际字符串是我对Java8是新手，我将从我的映射中获取一堆密钥，在这里我需要提取8中不匹配的部分

我的最终映射应该由一个字符串组成，第一个字符串是键，值是不匹配的部分。在Java8中，我应该如何做到这一点

Pattern p =Pattern.compile("I am new to Java (*)");

map= map.entrySet()
        .stream()
        .filter(p -> p.getKey().contains("Java")&&p.getKey().matches("I am new to Java (*)"))
        .collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()));

我正在使用下面的一个，它坏了，有人能建议吗

我想要像这样的东西

Map<String, String> result=map.entrySet().stream().filter(k-> k.getKey().matches(test) && k.getKey().contains(test))
        .collect(Collectors.toMap(k->k.getKey(), ::p.matcher().group(1)));

Map result=Map.entrySet（）.stream（）.filter（k->k.getKey（）.matches（测试）和&k.getKey（）.contains（测试））
.collect（Collectors.toMap（k->k.getKey（），：：p.matcher（）.group（1））；

我能用两张地图画出来

Map<String, String> result = new HashMap<>();
map.forEach((k,v)->{
            if(k.contains(test)) {
                while(p.matcher(k).find()) {
                    result.put(k, p.matcher(k).group(1));
                }
            }
        });

Map result=newhashmap（）；
图.forEach（（k，v）->{
如果（k.包含（测试））{
while（p.matcher（k.find（））{
结果：put（k，p.matcher（k）组（1））；
}
}
});

但如果我理解正确（并稍微简化了您的示例），我希望它出现在一张地图中：

String test=“我是Java 8新手”；
String t=“我是Java（.*）新手”；
Map Map=newhashmap（）；
地图放置（测试，“值1”）；
地图。放置（“一些”、“价值2”）；
Map result=Map.entrySet（）
.stream（）
.filter（e->！e.getKey（）.equals（e.getKey（）.replaceAll（t，“$1”））
.collect（collector.toMap）(
e->e.getKey（）.replaceAll（t，“$1”），
条目：：getValue））；

以下是我的做法：

Pattern p = Pattern.compile("I am new to Java (.*)");
Predicate<String> regexFilter = p.asPredicate();

Function<String,String> versionExtractor = str -> {
  Matcher m = p.matcher(str);
  if (m.find()) {
    return m.group(1);
  } else {
    throw new IllegalArgumentException("It didn't match !"); // should never happen since we match beforehand
  }
};

Map<String,String> result = inputMap.keySet()
  .stream()
  .filter(regexFilter)
  .collect(Collectors.toMap(Function.identity(), versionExtractor));

Pattern p=Pattern.compile（“我不熟悉Java（.*）”；
谓词regexFilter=p.asPredicate（）；
函数versionExtractor=str->{
匹配器m=p.Matcher（str）；
if（m.find（））{
返回m组（1）；
}否则{
抛出新的IllegalArgumentException（“它不匹配！”）；//不应该发生，因为我们事先进行了匹配
}
};
映射结果=inputMap.keySet（）
.stream（）
.filter（regexFilter）
.collect（Collectors.toMap（Function.identity（），versionExtractor））；

如果我没有弄错的话，您遇到的问题是无法在一条语句中将键映射到值，因为您需要先进行

.matches

，然后才能进行

.group

我们已经习惯了单行lambda（通过函数编程的强大功能实现），以至于我们有时会忘记它们是非常古老的

Function

s，并且它们没有这样的限制。在这里，我使用

{statements}

块定义了lambda，并将该lambda影响到一个变量，稍后我可以在流处理中引用该变量。我可以直接在流操作中定义lambda，也可以在不使用lambda表示法的情况下实现

函数

.
您的正则表达式不正确，看起来您想使用
我对Java（.*）
（
*
是一个量词，它通过指定以前的标记出现的次数来修改它；
（
不是一个可量化的标记；
，它将匹配任何字符，是）我使用（.*）但它仍然不起作用。它怎么不起作用？是否有错误消息或意外结果？添加了它@aarony您的新映射是使用
p.getValue（）
作为值创建的，因此您不应该期望该值神奇地成为您的正则表达式捕获的java版本号。看起来您的筛选器正常（尽管第一个条件是多余的：如果您的正则表达式匹配，则密钥显然包含“Java”），但您的收集器需要使用
Pattern
和
Matcher
从匹配的文本中提取第一组
Pattern p = Pattern.compile("I am new to Java (.*)");
Predicate<String> regexFilter = p.asPredicate();

Function<String,String> versionExtractor = str -> {
  Matcher m = p.matcher(str);
  if (m.find()) {
    return m.group(1);
  } else {
    throw new IllegalArgumentException("It didn't match !"); // should never happen since we match beforehand
  }
};

Map<String,String> result = inputMap.keySet()
  .stream()
  .filter(regexFilter)
  .collect(Collectors.toMap(Function.identity(), versionExtractor));