Normal ifade eşleşmeleri dizisi oluşturma

Java, ben bir diziye tüm regex maçları döndürmeye çalışıyorum ama sadece desen bir şey eşleşip eşleşmediğini (boolean) kontrol edebilirsiniz gibi görünüyor.

Belirli bir dizede normal ifade ile eşleşen tüm dizelerden oluşan bir dizi oluşturmak için normal ifade eşleşmesini nasıl kullanabilirim?

( Java> = 9 varsayabilirseniz, 4castle'ın cevabı aşağıdakilerden daha iyidir)

Bir eşleştirici oluşturmanız ve bunu eşleşmeli olarak eşleşmeleri bulmak için kullanmanız gerekir.

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

Bundan sonra allMatches, eşleşmeleri içerir ve allMatches.toArray(new String[0])gerçekten bir diziye ihtiyacınız varsa bir dizi almak için kullanabilirsiniz .

Geçerli grup durumunun anlık görüntüsünü döndürdüğünden MatchResult, eşleşmeler arasında döngü oluşturmak için yardımcı işlevler yazmak için de kullanabilirsiniz Matcher.toMatchResult().

Örneğin, yapmanıza izin vermek için tembel bir yineleyici yazabilirsiniz

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

böyle bir şey yaparak:

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

Bununla,

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

verim

a at 0
b at 1
a at 3
c at 4
a at 5
a at 7
b at 8
a at 10

Java 9'da, artık Matcher#results()birStream<MatchResult> bir eşleşmeler liste / dizisini almak için kullanabilir.

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 normal ifadeyi çok karmaşık hale getirir ve perl stilini takip etmez. Bunu tek bir Java kodu satırında nasıl başarabileceğinizi görmek için MentaRegex'e göz atın :

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

İşte basit bir örnek:

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

(daha fazla yakalama grubunuz varsa, grup yöntemine bağımsız değişken olarak dizinlerine göre bunlara başvurabilirsiniz. Bir diziye ihtiyacınız varsa kullanın list.toArray())

Gönderen Resmi 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;
        }

Sonucunu diziniz / Liste / öğenizde kullanın findve ekleyin 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;