expressões regulares Java

expressão regular define a cadeia padrão.

As expressões regulares podem ser usados ​​para pesquisar, editar ou processamento de texto.

As expressões regulares não estão limitados a um determinado idioma, mas existem diferenças sutis em cada idioma.

Java expressões regulares e Perl é o mais similar.

pacote java.util.regex inclui os seguintes três categorias:

• Categorias padrão:

  padrão de objeto é uma representação regular de compilador expressão. classe padrão tem nenhum construtor público. Para criar um objeto padrão, você deve primeiro chamar o método de compilação público estático que retorna um objeto padrão. Este método leva a uma expressão regular como seu primeiro argumento.

• Categorias Matcher:

  objeto Matcher é a interpretação da cadeia de entrada e operação de harmonização do motor. Como a classe Padrão, Matcher não tem nenhum construtor público. Você precisa chamar o método de objeto padrão de correspondência para obter um objeto Matcher.

• PatternSyntaxException:

  PatternSyntaxException é uma classe de exceção não-obrigatório que representa um regular erros de sintaxe padrão de expressão.

grupo de captura

grupos de captura são vários personagens quando um único métodos de tratamento da unidade, através dos caracteres agrupados entre parênteses para criar.

Por exemplo, a expressão regular (cão) cria um único grupo, o grupo que contém "d", "o", e "g".

grupo de captura, calculando a sua parêntese de abertura contados a partir da esquerda para a direita. Por exemplo, na expressão ((A), (B (C))), há quatro desses grupos:

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

Ao chamar o objeto groupCount forma de correspondência para ver quantos expressão pacotes. Método groupCount retorna um int representando o objeto de correspondência atualmente tem vários grupos de captura.

Há um grupo especial (grupo 0), ele sempre representa a expressão inteira. O grupo não está incluído no valor de retorno groupCount.

Exemplos

O exemplo a seguir mostra como encontrar uma seqüência de números de uma determinada string:

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

Os exemplos acima são compilados os resultados como se segue:

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

sintaxe de expressão regular

métodos de classe Matcher

Método Index

métodos de índice fornecem valores de índice úteis indicar com precisão onde encontrar os jogos cadeia de entrada:

Métodos de investigação

Métodos utilizados para verificar a cadeia de entrada e retorna um valor booleano que indica se ou não o padrão é encontrado:

método de substituição

Alternativa é substituir uma string no método de entrada de texto:

iniciar e método extremidade

Aqui está um exemplo do número de ocorrências na cadeia de entrada para contar a palavra "cat" aparece:

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

Os exemplos acima são compilados os resultados como se segue:

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

Isto pode ser visto usando os limites de palavra exemplo, para garantir que a letra "c" "a" "t" não é apenas uma longa substrings palavra. Ele também fornece algumas informações úteis sobre a cadeia de entrada é correspondido posições.

método Start retorna a operação durante a partida anterior, do grupo capturado subsequência dado índice inicial, terminar o método de combinar o último índice mais um personagem.

partidas método lookingAt

partidas e métodos lookingAt são usados ​​para tentar igualar uma seqüência de padrão de entrada. Eles são diferentes dos requisitos de toda a partida sequência de correspondência, mas não lookingAt necessário.

Estes dois métodos são muitas vezes utilizados na cadeia de entrada começa.

Através do seguinte exemplo para explicar este recurso:

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

Os exemplos acima são compilados os resultados como se segue:

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

métodos replaceFirst e replaceAll

Método replaceFirst e replaceAll usado para substituir o texto correspondente expressão regular. A diferença é, replaceFirst substituir o primeiro jogo, ReplaceAll substituir todas as correspondências.

O exemplo a seguir para explicar esse recurso:

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

Os exemplos acima são compilados os resultados como se segue:

The cat says meow. All cats say meow.

métodos appendReplacement e appendTail

classe Matcher também fornece um método para appendTail appendReplacement e substituir texto:

Olhe para o seguinte exemplo para explicar este recurso:

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

Os exemplos acima são compilados os resultados como se segue:

-foo-foo-foo-

métodos de classe PatternSyntaxException

PatternSyntaxException é uma classe de exceção não-obrigatório, o que indica um regulares erros de sintaxe padrão de expressão.

classe PatternSyntaxException fornece os seguintes métodos para nos ajudar a ver o que erro ocorreu.