Prefácio
Este artigo apresentará a classe de padrões e a classe Matcher nas expressões regulares de Java. Primeiro de tudo, precisamos entender claramente que a expressão regular especificada como uma string deve primeiro ser compilada como uma instância da classe de padrões. Portanto, como entender melhor essas duas classes é algo que os programadores devem conhecer.
Vamos dar uma olhada nessas duas categorias:
1. O conceito de captura de grupo
O grupo de captura pode ser numerado calculando seus suportes abertos da esquerda para a direita, que começa com 1. Por exemplo, na expressão ((a) (b (c)), existem quatro grupos:
1 ((a) (b (c))) 2 (a) 3 (b (c)) 4 (c)
Os zeros do grupo sempre representam toda a expressão. Os grupos que começam com (?) Grupos não de captura pura são que não capturam o texto e não contam contra a contagem de combinações.
A entrada de captura associada a um grupo é sempre a subseqüência que corresponde ao grupo mais recentemente. Se o grupo for calculado novamente devido à quantização, seu valor capturado anteriormente será retido na segunda falha de cálculo (se houver). Por exemplo, combinar a string "ABA" com a expressão (a (b)?)+ Definirá o segundo grupo como "B". No início de cada partida, todas as entradas capturadas são descartadas.
2. Explicação detalhada das classes de padrões e matchers
As expressões regulares Java são implementadas através da classe de padrões e da classe Matcher no pacote java.util.Regex (é recomendável que você abra o documento da API Java ao ler este artigo. Ao introduzir qual método é introduzido, verifique a descrição do método na API Java e o efeito será melhor).
A classe de padrões é usada para criar uma expressão regular, ou pode -se dizer que criar um padrão correspondente. Seu construtor é privado e não pode ser criado diretamente, mas pode criar uma expressão regular através do método simples de fábrica de Pattern.complie(String regex)
Exemplo de código Java:
Padrão p = padrão.compile ("// w+"); p.pattern (); // return/w+ pattern() Retorna a forma de sequência de uma expressão regular, que é na verdade o parâmetro regex do Pattern.complile(String regex)
1.pattern.split (entrada de charvekence)
O padrão possui um método split(CharSequence input) , que é usado para separar strings e retorna uma string []. Eu acho que String.split(String regex) é implementado através Pattern.split(CharSequence input) .
Exemplo de código Java:
Padrão p = padrão.compile ("// d+"); String [] str = p.split ("Meu QQ é: 456456 Meu telefone é: 0532214 Meu e -mail é: [email protected]");Resultado: str [0] = "Meu qq é:" str [1] = "Meu telefone é:" str [2] = "Meu e -mail é: [email protected]"
2. Pattern.Matcher (String regex, entrada de charsequence) é um método estático usado para corresponder rapidamente a strings. Este método é adequado para combinar apenas uma vez e combinar todas as cordas.
Exemplo de código Java:
Pattern.Matches ("// d+", "2223"); // retorna o verdadeiro padrão.matches ("// d+", "2223aa"); // retorna false, todas as cordas precisam ser correspondidas para retornar verdadeiro, aqui não pode corresponder a padrões.3.pattern.matcher (entrada de charventence)
Depois de dizer tanto, finalmente é a vez da classe Matchers. Pattern.matcher(CharSequence input) Retorna um objeto Matcher.
O método construtor da classe Matcher também é privado e não pode ser criado à vontade. Ele só pode obter instâncias dessa classe através Pattern.matcher(CharSequence input) .
A classe de padrões pode fazer apenas algumas operações de correspondência simples. Para obter operações de correspondência regulares mais fortes e convenientes, é necessário cooperar com o padrão e o Matcher. A classe Matcher fornece suporte de agrupamento para expressões regulares e suporte múltiplo para expressões regulares.
Exemplo de código Java:
Padrão p = padrão.compile ("// d+"); Matcher M = P.Matcher ("22BB23"); m.pattern (); // retorna p que é retornar qual objeto padrão foi criado pelo objeto Matcher.4.matcher.matches ()/Matcher.lookingat ()/Matcher.find ()
A classe Matcher fornece três métodos de operação correspondentes. Todos os três métodos retornam tipo booleano. Retorne verdadeiro quando a partida for alcançada. Se não houver correspondência, ele retornará falso.
matches() corresponde à string inteira e retorna true apenas se a string inteira corresponder
Exemplo de código Java:
Padrão p = padrão.compile ("// d+"); Matcher M = P.Matcher ("22BB23"); M.Matches (); // retorna false, porque o BB não pode ser correspondido por/d+, resultando na correspondência de toda a string sem êxito. Matcher M2 = P.Matcher ("2223"); m2.matches (); // retorna true, porque/d+ corresponde a toda a string Vamos olhar para o Pattern.matcher(String regex,CharSequence input) , o que é equivalente ao seguinte código
Pattern.compile(regex).matcher(input).matches()
lookingAt() corresponde à sequência anterior e retorna verdadeiro apenas se a sequência correspondente estiver na frente.
Exemplo de código Java:
Padrão p = padrão.compile ("// d+"); Matcher M = P.Matcher ("22BB23"); m.lookingat (); // retorna true, porque/d+ corresponde ao 22 Matcher M2 anterior = P.Matcher ("AA2223"); m2.lookingat (); // retorna false, porque/d+ não pode corresponder ao AA anterior find() corresponde à string e a string correspondente pode estar em qualquer lugar.
Exemplo de código Java:
Padrão p = padrão.compile ("// d+"); Matcher M = P.Matcher ("22BB23"); m.find (); // retorna o verdadeiro correspondente m2 = p.matcher ("aa2223"); m2.find (); // retorna o verdadeiro correspondente m3 = p.matcher ("aa2223bb"); m3.find (); // retorna o verdadeiro correspondente m4 = p.matcher ("aabb"); m4.find (); // retorna false5.MathCer.Start ()/Matchaer.end ()/Matcher.group ()
Depois de usar matches() , lookingAt() e find() para executar operações correspondentes, você pode usar os três métodos acima para obter informações mais detalhadas.
start() retorna a posição do índice da substring correspondente na string.
end() retorna a posição do índice do último caractere da substring correspondente na string.
group() retorna a substring correspondente
Exemplo de código Java:
Padrão p = padrão.compile ("// d+"); Matcher M = P.Matcher ("AAA2223BB"); m.find (); // corresponde a 2223 m.start (); // retornar 3 M.END (); // retornar 7, o número do índice após 2223 m.group (); // retornar 2223 Mathcer M2 = M.Matcher ("2223BB"); m.lookingat (); // corresponde a 2223 m.start (); // retorna 0, como Lookingat () pode corresponder apenas à sequência anterior, ao usar Lookingat () para corresponder, o método START () sempre retorna 0 m.end (); // retorna 4 m.group (); // retorna 2223 Matcher M3 = M.Matcher ("2223BB"); M.Matches (); // corresponde a toda a string m.start (); // retorna 0, acredito que todos conhecem o motivo de M.END (); // retorna 6, acredito que todo mundo sabe o motivo, porque o Matches () precisa corresponder a todas as string m.group (); // retorna 2223bb Dito tanto, acredito que todo mundo entende o uso dos métodos acima. Devemos falar sobre como o agrupamento regular de expressão é usado em Java.
Existe um método sobrecarregado para start() , end() e group() Eles são start(int i) , end(int i) , group(int i) especificamente para operações de grupo. A classe Mathcer também tem um groupCount() para retornar quantos grupos existem.
Exemplo de código Java:
Padrão p = padrão.compile ("([AZ]+) (// d+)"); Matcher M = P.Matcher ("AAA2223BB"); m.find (); // corresponde a AAA2223 M.GroupCount (); // retorna 2, porque existem 2 grupos de M.Start (1); // return 0 retorna o número de índice do primeiro grupo de substrings correspondentes na string m.start (2); // retorna 3 M.End (1); // Retorna 3 retorna a posição do índice do último caractere do primeiro grupo de substringas correspondentes na sequência. M.nd (2); // retorna 7 M.Group (1); // retorna AAA, retorna o primeiro grupo de substringas correspondentes M.Group (2); // retorna 2223, retorne o segundo conjunto de substringas correspondentes Agora, vamos usar uma operação de correspondência regular um pouco mais alta, por exemplo, há um texto com muitos números nele, e esses números são separados. Agora precisamos tirar todos os números do texto. É tão simples usar operações regulares Java.
Exemplo de código Java:
Padrão p = padrão.compile ("// d+"); Matcher M = P.Matcher ("Meu QQ é: 456456 Meu telefone é: 0532214 Meu e -mail é: [email protected]"); while (m.find ()) {System.out.println (M.Group ()); }Saída:
456456 0532214 123
Se você substituir o loop acima while()
while (m.find ()) {System.out.println (M.Group ()); System.out.print ("Start:"+M.Start ()); System.out.println ("END:"+M.END ()); }Em seguida, saída:
456456 Início: 6 Fim: 12 0532214 Início: 19 Fim: 26 123 Início: 36 Fim: 39
Agora, todos devem saber que, após cada operação correspondente, os valores dos três métodos start() , end() e group() serão alterados e serão alterados para as informações da substring correspondente, e seus métodos de sobrecarga também serão alterados para as informações correspondentes.
NOTA: Somente quando a operação correspondente for bem -sucedida, você pode usar os três métodos start() , end() e group() , caso contrário, java.lang.IllegalStateException serão lançados, ou seja, quando qualquer um dos métodos matches() , lookingAt() , find() retornar, só pode ser usado.
Resumir
O exposto acima é todo o conteúdo deste artigo. Espero que o conteúdo deste artigo seja de ajuda para o seu estudo ou trabalho. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.