Como todos sabemos, no desenvolvimento do programa, é inevitável encontrar situações em que as cordas precisam ser correspondidas, pesquisadas, substituídas e julgadas. Essas situações às vezes são mais complicadas. Se resolvido em codificação pura, muitas vezes desperdiça o tempo e a energia dos programadores. Portanto, aprender e usar expressões regulares se tornaram os principais meios para resolver essa contradição.
Como todos sabemos, expressões regulares são uma especificação que pode ser usada para correspondência e substituição de padrões. Uma expressão regular é um padrão literal composto por caracteres comuns (como caracteres A a Z) e caracteres especiais (metacaracters). É usado para descrever uma ou mais cordas a serem correspondentes ao procurar o corpo de um literal. A expressão regular atua como um modelo para corresponder a um padrão de caracteres com a string pesquisada.
Desde que o JDK1.4 lançou o pacote java.util.regex, ele nos forneceu uma boa plataforma de aplicativos de expressão regular Java.
Como as expressões regulares são um sistema muito complexo, só darei alguns exemplos de conceitos introdutórios. Para mais informações, consulte os livros relacionados e explore -os você mesmo.
// barra de barriga
/t intervalo ('/u0009')
/n quebra de linha ('/u000a')
/r enter ('/u000d')
/D Número é equivalente a [0-9]
/D Não-dígitos é equivalente a [^0-9]
/s símbolo em branco [/t/n/x0b/f/r]
/S símbolo não em branco [^/t/n/x0b/f/r]
/w Personagem individual [a-ZA-Z_0-9]
/W personagem não individual [^a-za-z_0-9]
/f quebra de página
/e escape
/b o limite de uma palavra
/B Um limite não-palavras
/G Fim da partida anterior
^ começa com limite
^O limite de condição de Java é para caracteres que começam com Java
$ é o fim do limite
O limite de condição Java $ é de caracteres java-end
. Limites condicionais qualquer caractere, exceto /n
Java .. Após o limite de condição, é Java, quaisquer dois caracteres, exceto a nova linha
Adicione restrições específicas "[]"
[AZ] as condições são limitadas a um caractere na faixa minúscula de A a Z
[AZ] as condições são limitadas a um caractere na linha de maiúsculas A a Z
As condições [A-ZA-Z] são limitadas a um caractere na linha minúscula A a Z ou OUPERCASE A a Z
As condições são limitadas a um caractere na faixa minúscula de 0 a 9
As condições [0-9a-z] são limitadas a minúsculas de 0 a 9 ou a uma faixa
As condições [0-9 [AZ]] são limitadas a minúsculas de 0 a 9 ou a uma faixa Z (interseção)
[] e adicione a condição de restrição "[^]" novamente
As condições [^AZ] são limitadas a um personagem na faixa de não-lowercase A a Z
[^AZ] condição limita um caractere na faixa não-caps a a z
As condições [^a-za-z] são limitadas a um caractere na faixa de não-lowercase A a Z ou OUPERCASE A a Z
[^0-9] As condições são limitadas a um caractere na faixa de não-lowercase de 0 a 9
As condições [^0-9a-z] são limitadas a um personagem na faixa de não-lowercase de 0 a 9 ou a a z
As condições [^0-9 [AZ]] são limitadas a um caractere na faixa de não lowercase de 0 a 9 ou a a z (interseção)
Quando a condição de restrição é que um personagem específico aparece mais de 0 vezes, você pode usar "*" "
J* mais de 0 j
.* Qualquer personagem acima de 0
J.*DJ e D Qualquer 0 caracteres
Quando a condição de restrição é que um personagem específico aparece mais de uma vez, você pode usar "+"
J+ 1 ou mais j
.+ 1 ou mais caracteres arbitrários
J.+1 ou mais caráter entre DJ e D
Quando a condição de restrição é que um personagem específico aparece 0 ou mais vezes "?" pode ser usado.
JA? J ou JA aparece
Limite para a ocorrência contínua do caractere do número especificado "{a}"
J {2} JJ
J {3} JJJ
Mais do que um texto e "{a,}"
J {3,} jjj, jjjjj, jjjjj, ??? (J coexiste mais de 3 vezes)
Mais de um texto, menos de B "{a, b}"
J {3,5} jjj ou jjjj ou jjjjj
Pegue um dos dois
J | aj ou a
Java | Olá java ou olá
"()" Especifica um tipo de combinação, por exemplo, se eu consultar os dados entre <a href =/"index.html/"> índice </a>, posso escrever <a.*href =/".*/"> (.+?) </a>
Ao usar a função Pattern.compile, você pode adicionar parâmetros que controlam o comportamento correspondente das expressões regulares:
Pattern Pattern.compile (String regex, int flag)
A gama de valores de bandeiras é a seguinte:
Pattern.Canon_Eq A correspondência é determinada se e somente se a "decomposição canônica" dos dois caracteres for exatamente a mesma. Por exemplo, depois de usar esse sinalizador, a expressão "A/U030A" corresponderá "?". Por padrão, "igualdade canônica" não é considerada.
Pattern.Case_Insensitive (? I) por padrão, a correspondência de caso-uniforme de caso está disponível apenas para conjuntos de caracteres US-ASCII. Esse sinalizador permite que as expressões ignorem o caso da correspondência. Para corresponder aos caracteres Unicode com o tamanho desconhecido, basta combinar Unicode_case com este sinalizador.
Pattern.Comments (? X) Nesse modo, os caracteres do espaço (em expressões regulares) serão ignorados ao corresponder (Nota do tradutor: não se refere a "// s" na expressão, mas refere -se a espaços, guias, retorno de carruagem etc.) na expressão. Os comentários começam em # e terminam nesta linha. O modo de linha Unix pode ser ativado por meio de sinalizadores incorporados.
Pattern.Dotall (? S) Neste modo, a expressão '.'. pode corresponder a qualquer caractere, incluindo o caractere final que representa uma linha. Por padrão, a expressão '.' não corresponde ao caráter final da linha.
Pattern.Multiline
(? M) Neste modo, '^' e '$' correspondem ao início e final de uma linha, respectivamente. Além disso, '^' ainda corresponde ao início da string e '$' também corresponde ao final da string. Por padrão, essas duas expressões correspondem apenas ao início e final da string.
Pattern.unicode_case
(? U) Nesse modo, se você também habilitar o sinalizador CASE_insensitive, ele corresponderá aos caracteres Unicode com o caso não identificado. Por padrão, a correspondência insensível ao caso está disponível apenas para conjuntos de caracteres US-ASCII.
Pattern.Unix_Lines (? D) Neste modo, apenas '/n' é considerado um aborto de uma linha e corresponde '.', '^' E '$'.
Deixando de lado o conceito vazio, aqui estão alguns casos simples de uso regular Java:
◆ Por exemplo, quando a string contém verificação
// Encontre uma string que começa com Java e termina em Will Pattern = Pattern.compile ("^Java.*"); Matcher Matcher = Pattern.Matcher ("Java não é humano"); booleano b = matcher.matches (); // Quando a condição é satisfeita, ele retornará verdadeiro, caso contrário, False System.out.println (b); ◆ Ao dividir as cordas com várias condições
Padrão padrão = padrony.compile ("[, |]+"); string [] strs = padrony.split ("java hello world java, hello ,, mundo | ◆ Substituição de texto (o caractere aparece pela primeira vez)
Padrão padrão = padrão.compile ("Expressão regular"); Matcher Matchaer = Pattern.Matcher ("Expressão regular Hello World, Expression Regular Hello World"); // Substitua os primeiros dados que cumprem o sistema de regularidade.out.println (matcher.replacefirst ("java")); ◆ Substituição de texto (tudo)
Padrão padrão = padrão.compile ("Expressão regular"); Matcher Matchaer = Pattern.Matcher ("Expressão regular Hello World, Expressão regular Hello World"); // Substitua os primeiros dados que cumprem o sistema de regularidade.out.println (MatchaR.ReplaceAll ("Java")); ◆ Substituição de texto (substitua caracteres)
Padrão padrão = padrão.compile ("Expressão regular"); Matcher Matcher = Pattern.Matcher ("Expressão regular Hello World, Expressão regular Hello World"); StringBuffer SBR = new StringBuffer (); while (matcher.find ()) {Matcher.appendReplacement (sbr, "java");} matcher.appendtail (sbr); system.out.println (sb.toString ());◆ Verifique se é um endereço de e -mail
String str = "[email protected]"; padrão padrão = padrony.compile ("[// w //.//- ]+@(// w //- ]+//.)
◆ Remova as tags HTML
Padrão padrão = padrão.compile ("<.+?>", Padrony.Dotall); Matcher Matcher = Pattern.Matcher ("<a href =/" index.html/"> home </a>"); string = matcher.ReplaceAll (""); System.out.println (String); ◆ Encontre a sequência de condição correspondente em html
Padrão padrão = padrão.compile ("href =/" (.+?)/""); Matcher Matcher = Pattern.matcher ("<a href =/" index.html/"> home </a>"); if (foder.find ()) System.out.println (matcher.group (1)); ◆ Interceptar http: // endereço
// interceptar urlpattern padrão = padrão.compile ("(http: // | https: //) {1} [//w//.////:]+"); matcher matcher = Pattern.matcher ("dsdsds <http: // dsds // gfgffdfd> fdfd"); while (matcher.find ()) {buffer.append (matcher.group ()); buffer.append ("/r/n"); System.out.println (buffer.toString ());}◆ Substitua os caracteres especificados {} chineses
String str = "O histórico de desenvolvimento atual do Java é de {0} anos - {1} anos"; string [] [] objeto = {new String [] {"// {0 //}", "1995"}, string [] {"// {1 //}" "2007"}}; Sourcestring, objeto [] objeto) {string temp = soucestring; for (int i = 0; i <object.Length; i ++) {string [] resultado = (string []) objeto [i]; Padrão padrão = padrão.compile (resultado [0]); Matcher Matcher = Pattern.Matcher (Temp); temp = matcher.Replaceall (resultado [1]); } retornar temp;}◆ Arquivos de consulta em diretórios designados com condições regulares
// usado para cache arquivos de arquivos arquivos privados Arquivos = new ArrayList (); // usado para hospedar o caminho do arquivo Private String _Path; // costumava hospedar fórmula regular não servida string privada _Regexp; classe MyFileFilter implementa o FileFilter { / *** Combine o nome do arquivo* / public boolean Acep (arquivo de arquivo) {try {padrony Pattern.compile (_Regexp); Matcher Match = Pattern.Matcher (File.getName ()); retornar match.matches (); } catch (Exceção e) {return true; }}} / *** Analise o fluxo de entrada* @param entradas* / filesAnalyze (caminho da string, string regexp) {getFileName (path, regexp); } /** * Analise o nome do arquivo e adicione arquivos * @param input * /private void getFilename (caminho da string, string regexp) {// diretório_path = path; _Regexp = regexp; Diretório de arquivos = novo arquivo (_path); Arquivo [] filefile = diretório.listfiles (new MyFileFilter ()); if (filesfile == null) retornar; for (int j = 0; j <filesfile.length; j ++) {files.add (filesfile [j]); } retornar; } / *** Mostrar informações de saída* @param out* / public void Print (printStream Out) {iterator Elements = files.iterator (); while (elements.hasNext ()) {arquivo file = (file) elements.Next (); out.println (file.getPath ()); }} public static void Output (caminho da string, string regexp) {fileSanalyze fileGroup1 = new FileNalyze (caminho, regexp); fileGroup1.print (System.out); } public static void main (string [] args) {output ("c: //", "[az |.]*"); }Existem muitas funções da regularidade do Java. De fato, desde que seja processamento de personagens, não há nada que a regularidade não possa fazer. (Claro, leva muito tempo para explicar regularmente ||| ...)
O exposto acima estão as informações que resolvem expressões regulares do Java. Continuaremos a adicionar informações relevantes no futuro. Obrigado pelo seu apoio a este site!