정규식 일치 배열 만들기

Java에서는 모든 정규식 일치를 배열로 반환하려고하지만 패턴이 일치하는지 (부울) 여부 만 확인할 수있는 것 같습니다.

정규식 일치를 사용하여 주어진 문자열에서 정규식과 일치하는 모든 문자열의 배열을 구성하려면 어떻게해야합니까?

( Java> = 9라고 가정하면 4castle의 대답 이 아래보다 낫습니다.)

매처를 작성하고이를 사용하여 반복적으로 일치하는 항목을 찾아야합니다.

 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 at 0
b at 1
a at 3
c at 4
a at 5
a at 7
b at 8
a at 10

자바 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())

Java는 정규식을 너무 복잡하게 만들고 perl 스타일을 따르지 않습니다. 한 번 봐 가지고 MentaRegex를 자바 코드 한 줄에 그것을 달성 할 수있는 방법을 보려면 :

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

다음은 간단한 예입니다.

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())

로부터 공식 정규식 자바 트레일 :

        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를 배열 / 목록 / 무엇이든 사용 하고 삽입하십시오 .

        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;