Java reguläre Ausdrücke

Regulärer Ausdruck definiert die Musterkette.

Reguläre Ausdrücke können zur Suche verwendet werden, zu bearbeiten, oder die Bearbeitung von Text.

Reguläre Ausdrücke werden auf eine bestimmte Sprache beschränkt, sondern es gibt subtile Unterschiede in jeder Sprache.

Java reguläre Ausdrücke und Perl ist das ähnlich.

java.util.regex Paket umfasst die folgenden drei Kategorien:

• Muster Kategorien:

  Objekt Muster ist ein regulärer Ausdruck Compiler Darstellung. Pattern-Klasse hat keinen öffentlichen Konstruktor. Um ein Pattern-Objekt erstellen, müssen Sie zuerst seine öffentliche statische Kompilierung Methode aufrufen, die ein Pattern-Objekt zurückgibt. Diese Methode nimmt einen regulären Ausdruck als erstes Argument.

• Matcher Kategorien:

  Matcher Aufgabe ist die Interpretation des Eingabestrings und passenden Betrieb des Verbrennungsmotors. Wie die Pattern-Klasse, hat Matcher keinen öffentlichen Konstruktor. Sie müssen die Methode Pattern Matcher Objekt aufrufen ein Matcher-Objekt zu erhalten.

• Pattern:

  Pattern ist eine nicht-obligatorischen Ausnahmeklasse, die einem regulären Ausdruck Syntaxfehler darstellt.

Capture-Gruppe

Erfassen von Gruppen sind mehrere Zeichen, wenn eine einzelne Einheit Behandlungsmethoden, durch die Zeichen in Klammern gruppiert zu erstellen.

Beispielsweise erstellt der reguläre Ausdruck (Hund) eine einzige Gruppe, die Gruppe, die "d", "o" und "g" enthält.

Capture-Gruppe, die durch ihre offene Klammer von links nach rechts durchnummeriert zu berechnen. Beispielsweise in dem Ausdruck ((A) (B (C))), gibt es vier solche Gruppen:

• ((A) (B (C)))
• (A)
• (B (C))
• (C)

Durch den Aufruf der Matcher-Objekt Groupcount Art und Weise, wie viele Pakete Ausdruck zu sehen. Groupcount-Methode gibt einen int, die die Matcher-Objekt derzeit mehrere Capture-Gruppen hat.

Es gibt eine spezielle Gruppe (Gruppe 0), ist es immer den gesamten Ausdruck darstellt. Die Gruppe ist nicht in Groupcount Rückgabewert enthalten.

Beispiele

Das folgende Beispiel zeigt, wie eine Reihe von Zahlen aus einer bestimmten Zeichenfolge zu finden:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    public static void main( String args[] ){

      // 按指定模式在字符串查找
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // 创建 Pattern 对象
      Pattern r = Pattern.compile(pattern);

      // 现在创建 matcher 对象
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      } else {
         System.out.println("NO MATCH");
      }
   }
}

Die obigen Beispiele kompilierten Ergebnisse sind wie folgt:

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Syntax für reguläre Ausdrücke

Matcher Klassenmethoden

Index-Methode

Index Methoden liefern nützliche Indexwerte genau angeben, wo die Eingabezeichenfolge Übereinstimmungen zu finden:

Forschungsmethoden

Methoden verwendet, um die Eingabezeichenfolge zu überprüfen und gibt einen Booleschen Wert, der angibt, ob das Muster gefunden wird:

Ersatzverfahren

Alternative ist eine Zeichenfolge in das Texteingabemethode zu ersetzen:

Beginn und Ende Methode

Hier ist ein Beispiel für die Anzahl von Vorkommen in der Eingabezeichenfolge zum Zählen das Wort "Katze" erscheint:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT =
                                    "cat cat cat cattie cat";

    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // 获取 matcher 对象
       int count = 0;

       while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Die obigen Beispiele kompilierten Ergebnisse sind wie folgt:

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Dies kann am Beispiel Wortgrenzen zu sehen ist, um sicherzustellen, dass der Buchstabe "c" "a" "t" ist nicht nur ein langes Wort Strings. Es bietet auch einige nützliche Informationen über die eingegebene Zeichenkette Positionen abgestimmt.

Start-Methode gibt den Betrieb während des vorherigen Spiel von der ersten Gruppe erfasst Teilfolge Index gegeben, die Methode der Anpassung des letzten Index plus ein Zeichen enden.

Streichhölzer und lookingAt Verfahren

sind Spiele und lookingAt Methoden verwendet, um zu versuchen eine Folge von Eingabemuster entsprechen. Sie unterscheiden sich von den Anforderungen der gesamten Sequenz matcher Spiel, aber lookingAt nicht erforderlich.

Diese beiden Verfahren werden häufig verwendet, in der Eingabezeichenfolge beginnt.

Durch das folgende Beispiel diese Funktion zu erklären:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);

       System.out.println("Current REGEX is: "+REGEX);
       System.out.println("Current INPUT is: "+INPUT);

       System.out.println("lookingAt(): "+matcher.lookingAt());
       System.out.println("matches(): "+matcher.matches());
   }
}

Die obigen Beispiele kompilierten Ergebnisse sind wie folgt:

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst Methoden und replaceAll

replaceFirst und replaceAll Methode verwendet, um Text Anpassung regulären Ausdruck ersetzen. Der Unterschied ist, ersetzen replaceFirst das erste Spiel, replaceAll alle Spiele ersetzen.

Das folgende Beispiel diese Funktion zu erklären:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

Die obigen Beispiele kompilierten Ergebnisse sind wie folgt:

The cat says meow. All cats say meow.

appendReplacement Methoden und appendTail

Matcher-Klasse stellt auch ein Verfahren zur appendTail appendReplacement und Ersetzen von Text:

Schauen Sie sich das folgende Beispiel diese Funktion zu erklären:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // 获取 matcher 对象
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Die obigen Beispiele kompilierten Ergebnisse sind wie folgt:

-foo-foo-foo-

Patternklassenmethoden

Pattern ist eine nicht-obligatorischen Ausnahmeklasse, die eine regelmäßige Syntaxfehler Expressionsmuster zeigt.

Pattern-Klasse bietet die folgenden Methoden uns zu helfen, sehen, was Fehler aufgetreten ist.