Java espressioni regolari

espressione regolare definisce la stringa modello.

Le espressioni regolari possono essere utilizzati per la ricerca, modificare o elaborazione del testo.

Le espressioni regolari non sono limitati a una certa lingua, ma ci sono sottili differenze in ogni lingua.

Java espressioni regolari e Perl è la più simile.

pacchetto java.util.regex comprende le seguenti tre categorie:

• categorie del modello:

  modello oggetto è una rappresentazione espressione regolare compilatore. classe del modello non ha costruttore pubblico. Per creare un oggetto del modello, è necessario innanzitutto chiamare il suo metodo di compilazione public static che restituisce un oggetto modello. Questo metodo prende un'espressione regolare come primo argomento.

• categorie Matcher:

  oggetto Matcher è l'interpretazione della stringa di input e il funzionamento corrispondenza del motore. Come la classe del modello, Matcher non ha costruttore pubblico. È necessario chiamare il modello oggetto Matcher metodo per ottenere un oggetto Matcher.

• PatternSyntaxException:

  PatternSyntaxException è una classe di eccezione non obbligatorio che rappresenta un normale errori di sintassi del modello di espressione.

gruppo di cattura

gruppi di cattura sono più caratteri in cui un singolo metodi di trattamento unità, attraverso i personaggi raggruppati tra parentesi a creare.

Ad esempio, l'espressione regolare (cane) crea un unico gruppo, il gruppo che contiene "d", "O", e "g".

gruppo Capture calcolando la sua parentesi aperta numerati da sinistra a destra. Ad esempio, nell'espressione ((A) (B (C))), ci sono quattro gruppi:

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

Chiamando il matcher oggetto groupCount modo per vedere quanti espressione pacchetti. Metodo groupCount restituisce un int che rappresenta l'oggetto matcher attualmente ha più gruppi di acquisizione.

C'è un gruppo speciale (gruppo 0), rappresenta sempre l'intera espressione. Il gruppo non è incluso nel valore di ritorno groupCount.

Esempi

L'esempio seguente mostra come trovare una stringa di numeri da una stringa:

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

Gli esempi sopra risultati elaborati sono i seguenti:

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

sintassi delle espressioni regolari

metodi di classe Matcher

Metodo Indice

metodi Indice forniscono valori di indice utili indicano esattamente dove trovare le partite stringa di input:

Metodi di ricerca

I metodi utilizzati per verificare la stringa di input e restituisce un valore booleano che indica se il modello viene trovato:

metodo di sostituzione

Alternativa è quello di sostituire una stringa nel metodo di immissione del testo:

inizio e fine il metodo

Ecco un esempio del numero di occorrenze nella stringa di input per contare la parola compare "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());
      }
   }
}

Gli esempi sopra risultati elaborati sono i seguenti:

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

Questo può essere visto utilizzando i confini di parola esempio, per garantire che la lettera "c" "a" "t" non è solo una lunga sottostringhe parola. Esso fornisce inoltre alcune informazioni utili riguardo la stringa di input è abbinato posizioni.

metodo start restituisce l'operazione durante la partita precedente, dall'indice dato gruppo catturato sottosequenza iniziale, finisce il metodo di abbinare l'ultimo indice più uno carattere.

sue partite e metodo lookingat

sue partite e dei metodi lookingat sono utilizzati per cercare di abbinare una sequenza di pattern di input. Sono diversi dai requisiti di tutta la partita la sequenza Matcher, ma non lookingat necessaria.

Questi due metodi sono spesso utilizzati in inizia stringa di input.

Attraverso il seguente esempio per spiegare questa caratteristica:

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

Gli esempi sopra risultati elaborati sono i seguenti:

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

metodi replaceFirst e replaceAll

Metodo replaceFirst e replaceAll utilizzato per sostituire il testo corrispondente espressione regolare. La differenza è, replaceFirst sostituire la prima partita, ReplaceAll sostituire tutte le partite.

Il seguente esempio per spiegare questa caratteristica:

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

Gli esempi sopra risultati elaborati sono i seguenti:

The cat says meow. All cats say meow.

metodi appendReplacement e appendTail

classe Matcher fornisce anche un metodo per appendTail appendReplacement e sostituire il testo:

Guardate il seguente esempio per spiegare questa caratteristica:

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

Gli esempi sopra risultati elaborati sono i seguenti:

-foo-foo-foo-

metodi di classe PatternSyntaxException

PatternSyntaxException è una classe di eccezione non obbligatorio, il che indica un normale errori di sintassi del modello di espressione.

Classe PatternSyntaxException fornisce i seguenti metodi per aiutarci a vedere che cosa è verificato un errore.