wyrażenia regularne Java

Wyrażenie regularne definiuje ciąg wzoru.

Wyrażenia regularne mogą być wykorzystane do wyszukiwania, edytować lub przetwarzania tekstu.

Wyrażenia regularne nie są ograniczone do pewnego języka, ale istnieją subtelne różnice w każdym języku.

Java wyrażeń regularnych i Perl jest najbardziej podobna.

Pakiet java.util.regex obejmuje następujące trzy kategorie:

• Kategorie Wzór:

  wzór Obiekt jest zwykłym przedstawieniem kompilator wypowiedzi. Klasa wzór ma konstruktora publicznego. Aby utworzyć obiekt wzór, należy najpierw wywołać jej publiczną statyczną metodę kompilacji, która zwraca obiekt wzór. Ta metoda pobiera wyrażenie regularne jako pierwszy argument.

• Matcher kategorie:

  Matcher celem jest interpretacja ciągu wejściowego i dopasowanie pracy silnika. Podobnie jak w przypadku klasy Pattern Matcher ma konstruktora publicznego. Trzeba wywołać metodę dopasowania wzorca obiektu w celu uzyskania obiektu Matcher.

• PatternSyntaxException:

  PatternSyntaxException jest nieobowiązkowa klasy wyjątek stanowi regularny wzór ekspresji błędy składniowe.

grupa przechwytywania

Przechwytywanie grupy są wiele znaków, gdy pojedyncza jednostka metody leczenia, za pośrednictwem znaków zgrupowanych w nawiasach utworzyć.

Na przykład, wyrażenie regularne (pies) tworzy jedną grupę, grupę, która zawiera "D", "O" i "g".

grupa przechwytywania przez obliczenie jego otwartego nawiasu numerowane od lewej do prawej. Na przykład, w wyrażeniu ((A), (B (C))), znajdują się cztery takie grupy:

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

Wywołując Matcher obiektu groupCount sposób, aby zobaczyć ile wyraz pakietów. Metoda groupCount zwraca int reprezentujący obiekt Matcher obecnie ma wiele grup przechwytywania.

Istnieje specjalna grupa (grupa 0), to zawsze reprezentuje cały wyraz. Grupa nie jest wliczone w groupCount wartości zwracanej.

Przykłady

Poniższy przykład pokazuje, jak znaleźć ciąg liczb z danego ciągu znaków:

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

Powyższe przykłady zebrane wyniki przedstawiają się następująco:

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

Składnia wyrażeń regularnych

Matcher metody klasy

Metoda index

Metody Index dostarczyć użytecznych wartości indeksu precyzyjnie wskazuje, gdzie można znaleźć wyniki ciąg wejściowy:

Metody badawcze

Metody wykorzystywane do sprawdzenia ciąg wejściowy i zwraca wartość logiczną wskazującą, czy wzorzec zostanie znaleziony:

metoda zastępcza

Alternatywą jest zastąpić ciąg w metodzie wprowadzania tekstu:

Metoda start i end

Oto przykład liczby zdarzeń w ciągu wejściowego do zliczania słów pojawia "cat":

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

Powyższe przykłady zebrane wyniki przedstawiają się następująco:

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

Można to zaobserwować na przykładzie granicy słowa, aby upewnić się, że litera "c" "a" "t" nie jest tylko długie podciągi słowo. Zapewnia również kilka przydatnych informacji na temat łańcucha wejściowego jest dopasowane pozycje.

Metoda start zwraca operację podczas poprzedniego spotkania z początkowego indeksu danej grupy przechwycone podciąg, zakończyć metodę dopasowania ostatni indeks plus jeden znak.

mecze i metody lookingat

mecze i metody lookingat służą do spróbować dopasować sekwencję wzorca wejściowego. Różnią się one od wymagań całej sekwencji dopasowywania meczu, ale nie lookingat wymagane.

Te dwa sposoby są często stosowane w rozpoczyna się ciąg wejściowych.

Dzięki poniższym przykładzie wyjaśnić tę funkcję:

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

Powyższe przykłady zebrane wyniki przedstawiają się następująco:

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

replaceFirst metody i replaceAll

Metoda replaceFirst i replaceAll stosowany w celu zastąpienia tekst pasujący do wyrażenia regularnego. Różnica jest, replaceFirst wymienić pierwszy mecz, replaceAll wymienić wszystkie mecze.

Poniższy przykład wyjaśnić tę funkcję:

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

Powyższe przykłady zebrane wyniki przedstawiają się następująco:

The cat says meow. All cats say meow.

appendReplacement metody i appendTail

Klasa Matcher zapewnia również sposób appendTail appendReplacement i zastąpić tekst:

Spójrz na poniższy przykład, aby wyjaśnić tę funkcję:

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

Powyższe przykłady zebrane wyniki przedstawiają się następująco:

-foo-foo-foo-

Metody klasy PatternSyntaxException

PatternSyntaxException jest nieobowiązkowa klasy wyjątku, co oznacza regularne błędy składniowe wzór ekspresji.

Klasa PatternSyntaxException zapewnia następujące metody, aby pomóc nam zobaczyć, co działo wystąpił błąd.