首页 文章

创建正则表达式匹配数组

提问于
浏览
121

在Java中,我试图将所有正则表达式匹配返回到数组,但似乎只能检查模式是否匹配(boolean) . 有人可以帮我使用正则表达式匹配来形成一个匹配给定字符串中的正则表达式的所有字符串的数组吗?谢谢!

6 回答

  • 20

    来自Official Regex Java Trails

    Pattern pattern = 
            Pattern.compile(console.readLine("%nEnter your regex: "));
    
            Matcher matcher = 
            pattern.matcher(console.readLine("Enter input string to search: "));
    
            boolean found = false;
            while (matcher.find()) {
                console.format("I found the text \"%s\" starting at " +
                   "index %d and ending at index %d.%n",
                    matcher.group(), matcher.start(), matcher.end());
                found = true;
            }
    

    使用 find 并将结果 group 插入您的数组/列表/等等 .

  • 25
    Set<String> keyList = new HashSet();
            Pattern regex = Pattern.compile("#\\{(.*?)\\}");
            Matcher matcher = regex.matcher("Content goes here");
            while(matcher.find()) {
                keyList.add(matcher.group(1)); 
            }
            return keyList;
    
  • 8

    这是一个简单的例子:

    Pattern pattern = Pattern.compile(regexPattern);
    List<String> list = new ArrayList<String>();
    Matcher m = pattern.matcher(input);
    while (m.find()) {
        list.add(m.group());
    }
    

    (如果你有更多的捕获组,你可以通过它们的索引引用它们作为组方法的参数 . 如果你需要一个数组,那么使用 list.toArray()

  • -1

    Java使得regex过于复杂,并且它不遵循perl风格 . 看看MentaRegex,了解如何在一行Java代码中实现这一目标:

    String[] matches = match("aa11bb22", "/(\\d+)/g" ); // => ["11", "22"]
    
  • 222

    在Java 9中,您现在可以使用Matcher#results()来获取Stream<MatchResult>,您可以使用它来获取匹配列表/数组 .

    import java.util.regex.Pattern;
    import java.util.regex.MatchResult;
    
    String[] matches = Pattern.compile("your regex here")
                              .matcher("string to search from here")
                              .results()
                              .map(MatchResult::group)
                              .toArray(String[]::new);
                        // or .collect(Collectors.toList())
    
  • 5

    (如果您可以假设Java> = 9,则4castle's answer优于以下内容)

    您需要创建一个匹配器并使用它来迭代查找匹配项 .

    import java.util.regex.Matcher;
     import java.util.regex.Pattern;
    
     ...
    
     List<String> allMatches = new ArrayList<String>();
     Matcher m = Pattern.compile("your regular expression here")
         .matcher(yourStringHere);
     while (m.find()) {
       allMatches.add(m.group());
     }
    

    在此之后, allMatches 包含匹配项,如果您确实需要,可以使用 allMatches.toArray(new String[0]) 来获取数组 .


    您还可以使用 MatchResult 编写辅助函数来循环匹配,因为 Matcher.toMatchResult() 返回当前组状态的快照 .

    例如,您可以编写一个惰性迭代器来执行此操作

    for (MatchResult match : allMatches(pattern, input)) {
      // Use match, and maybe break without doing the work to find all possible matches.
    }
    

    做这样的事情:

    public static Iterable<MatchResult> allMatches(
          final Pattern p, final CharSequence input) {
      return new Iterable<MatchResult>() {
        public Iterator<MatchResult> iterator() {
          return new Iterator<MatchResult>() {
            // Use a matcher internally.
            final Matcher matcher = p.matcher(input);
            // Keep a match around that supports any interleaving of hasNext/next calls.
            MatchResult pending;
    
            public boolean hasNext() {
              // Lazily fill pending, and avoid calling find() multiple times if the
              // clients call hasNext() repeatedly before sampling via next().
              if (pending == null && matcher.find()) {
                pending = matcher.toMatchResult();
              }
              return pending != null;
            }
    
            public MatchResult next() {
              // Fill pending if necessary (as when clients call next() without
              // checking hasNext()), throw if not possible.
              if (!hasNext()) { throw new NoSuchElementException(); }
              // Consume pending so next call to hasNext() does a find().
              MatchResult next = pending;
              pending = null;
              return next;
            }
    
            /** Required to satisfy the interface, but unsupported. */
            public void remove() { throw new UnsupportedOperationException(); }
          };
        }
      };
    }
    

    有了这个,

    for (MatchResult match : allMatches(Pattern.compile("[abc]"), "abracadabra")) {
      System.out.println(match.group() + " at " + match.start());
    }
    

    产量

    a为0
    b为1
    a 3点
    c在4点
    a 5点
    a 7点
    b 8点
    一点十分

相关问题