1. regex (expressão regular): RegularExpressions (substituindo StringTokenizer); uma ferramenta poderosa para processamento de strings popular em Unix, Perl é ainda melhor usando regex;
Usado principalmente na correspondência, pesquisa e substituição de strings. Por exemplo: a correspondência de IP (intervalo inferior a 256) é fácil de usar com expressões regulares; extrair um grande número de endereços de e-mail de páginas da web para enviar spam; Contém Matcher (o resultado da correspondência de uma string com um padrão) e padrão.
Copie o código do código da seguinte forma:
/*
* Informa se esta string corresponde à expressão regular fornecida (também uma string).
*/
System.out.println("abc".matches("..."));//Cada "."
Copie o código do código da seguinte forma:
/*
* Substitua todos os números na string por "-". O método comum exige que charAt seja julgado um por um;
* "//d" representa qualquer número ou substitua-o por "[0-9]";
* "//D" representa qualquer não dígito ou substituído por "[^0-9]"
*/
System.out.println("ab54564654sbg48746bshj".replaceAll("[0-9]", "-"));//Cada "."
dois,
Copie o código do código da seguinte forma:
/*
* compile compila a expressão regular fornecida no padrão (cada compilação leva tempo); {3} significa exatamente três vezes.
* X{n} X, exatamente n vezes
* X{n,} X, pelo menos n vezes
* X{n,m} X, pelo menos n vezes, mas não mais que m vezes
*/
Padrão p = Pattern.compile("[az]{3}");
Matcher m = p.matcher("ggs"); //Crie um matcher que corresponda à entrada fornecida com este padrão. Internamente, um autômato de estado de prioridade é realmente criado (princípio de compilação)
//A string a ser correspondida no matcher e nas partidas é na verdade CharSequence (interface), mas String implementa esta interface e possui polimorfismo
System.out.println(m.matches());//Se for "ggss", não corresponderá
//Você sempre pode "ggs".matches("[az]{3}") diretamente, mas o acima tem vantagens, pelo menos é mais eficiente, e Pattern e Matcher fornecem muitas funções
3. Chame Meta Character em regex ". * +"; ctrl + shift + "/" significa comentário, substitua-o por "/" para remover o comentário.
Copie o código do código da seguinte forma:
"a".matches(".");//true, "." representa qualquer caractere, incluindo caracteres chineses.
"aa".matches("aa");//true, ou seja, strings comuns também podem ser usadas como expressões regulares
/*
* verdadeiro, "*" significa 0 ou mais caracteres, mas os caracteres seguintes devem ser iguais ao primeiro.
* Caso contrário, é falso, ou seja, avalia-se se a string é uma string composta por caracteres únicos.
*/
"aaaa".matches("a*");
"".matches("a*");//verdadeiro
"aaa".matches("a?"); //verdadeiro, uma vez ou 0 vezes
"".matches("a?");//verdadeiro
"a".matches("a?");//verdadeiro
"544848154564113".matches("//d{3.100}");//verdadeiro
//Este é o julgamento de IP mais simples, mas se exceder 255, não poderá ser julgado.
"192.168.0.aaa".matches("//d{1,3}//.//d{1,3}//.//d{1,3}//d{1,3}" );
"192".matches("[0-2][0-9][0-9]");
4. [abc] significa corresponder a qualquer caractere; [^abc] significa um caractere diferente de abc (ainda deve ser uma letra e false será retornado se for uma string vazia); "[az ]|[AZ]" é uma determinada letra maiúscula ou minúscula [AZ&&[ABS]] significa qualquer uma das letras maiúsculas e ABS.
Copie o código do código da seguinte forma:
//Descobri que não há diferença entre | e ||, mas há uma diferença entre & e && não sei se esta é a maneira correta de entender.
System.out.println("C".matches("[AZ&&[ABS]]"));//falso
System.out.println("C".matches("[AZ&[ABS]]"));//true
System.out.println("A".matches("[AZ&&[ABS]]"));//true
System.out.println("A".matches("[AZ&[ABS]]"));//true
System.out.println("C".matches("[AZ|[ABS]]"));//true
System.out.println("C".matches("[AZ||[ABS]]"));//true
5. /w caracteres de palavra: [a-zA-Z_0-9] ao combinar nomes de usuário; /s caracteres em branco: [ /t/n/x0B/f/r]; ] ;/W caracteres que não sejam palavras: [^/w].
Copie o código do código da seguinte forma:
" /n/t/r".matches("//s{4}");//true
" ".matches("//S");//falso
"a_8".matches("//w{3}");//verdadeiro
//"+" significa uma ou várias vezes
"abc888&^%".matches("[az]{1,3}//d+[&^#%]+");//true
/*
* O caractere a ser correspondido é apenas uma barra invertida, mas não pode ser escrito como "/" e depois combinado com o seguinte ",
* O anterior "não pode corresponder resultará em CE.
* não pode ser seguido de "//", caso contrário ocorrerá um erro de execução (sem problemas na compilação), deve ser escrito como "////"
*/
System.out.println("//".matches("////"));//true
6. Classe de caracteres POSIX (somente US-ASCII)
Copie o código do código da seguinte forma:
/p{Miúis} Caracteres alfabéticos minúsculos: [az] ;/p{Maiúsculas} Caracteres alfabéticos maiúsculos: [AZ] ;/p{ASCII} Todos os ASCII: [/x00-/x7F] ;/p{Alfa} Caracteres alfabéticos: [/p{Inferior}/p{Superior}] ;/p{Dígito} Número decimal: [0-9].
7. Correspondente de limite
^ Início da linha $ Fim da linha/b Limite de palavra/B Limite sem palavra/A Início da entrada/G Fim da correspondência anterior/Z Fim da entrada, usado apenas para o último terminador (se houver)
/z fim da entrada
Copie o código do código da seguinte forma:
"olá mundo".matches("^h.*");//O início da linha ^
"olá mundo".matches(".*ld$");//Fim da $linha
"olá mundo".matches("^h[az]{1,3}o//b.*");///limite bword
"helloworld".matches("^h[az]{1,3}o//b.*");
" /n".matches("^[//s&&[^//n]]*//n$");//Julgar linhas em branco, que começam com um caractere em branco
8. Você também pode usar m.start() e m.end() no método find para retornar o próximo entre a posição inicial e a posição final, se não puder ser encontrado, ocorrerá um erro;
Copie o código do código da seguinte forma:
Padrão p = Pattern.compile("//d{3,5}");
Strings = "133-34444-333-00";
Correspondente m = p.correspondente(s);
m.matches();//matches corresponde a todas as strings
m.reset();
/*
* Se o método de redefinição for chamado primeiro abaixo, verdadeiro, verdadeiro, verdadeiro, falso será gerado.
* Caso contrário, a penúltima descoberta também resultará em falso.
*Os motivos são os seguintes:
* corresponde ao primeiro "-" e descobre que não corresponde, mas esses quatro caracteres foram comidos. A correspondência começará novamente.
* 34444 começa, e a segunda busca começa em 333, porque find corresponde à próxima subsequência.
* O método reset permite que os fósforos cuspam a string comida pelos fósforos.
* Em resumo: reset deve ser usado entre matches e find, pois eles afetam um ao outro
*
*/
encontrar();
encontrar();
m.find();//Tenta encontrar a próxima subsequência da sequência de entrada que corresponde a este padrão
encontrar();
/*
* Tenta combinar uma sequência de entrada começando no início da região com este padrão.
* O autor de Thinking in java criticou severamente esse método porque não fica claro nas palavras por onde começar a correspondência.
* Todas as afirmações a seguir são verdadeiras, porque sempre começam do zero
*/
m.olhandoAt();
m.olhandoAt();
m.olhandoAt();
m.olhandoAt();
9. Substituição de cordas
Copie o código do código da seguinte forma:
importar java.util.regex.Matcher;
importar java.util.regex.Pattern;
classe pública TestRegexReplacement {
public static void main(String[] args) {
Padrão p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//O parâmetro a seguir é um número inteiro, que significa "sem distinção entre maiúsculas e minúsculas"
Matcher m = p.matcher("Java java hxsyl Ilovejava java JaVaAcmer");
enquanto(m.find()) {
System.out.println(m.group()); //m.group produzirá todo o java (ignorando maiúsculas e minúsculas)
}
String s = m.replaceAll("Java"); //String também possui este método
System.out.println(s);
m.reset();//deve ser adicionado porque find e matcher afetam um ao outro
StringBuffer sb = new StringBuffer();
int eu = 0;
/*
* O método a seguir é substituir o número ímpar de java encontrado por "Java" e o número par por "java"
*/
enquanto(m.find()) {
eu++;
//Não pode ser escrito diretamente como i&1 e deve ser convertido em booleano
se((i&1)==1) {
m.appendReplacement(sb, "Java");
}outro {
m.appendReplacement(sb, "java");
}
}
m.appendTail(sb);//Adiciona a string restante após o último java encontrado
System.out.println(sb);//Sem reset, apenas Acmer é gerado
}
}
10. Agrupamento
Copie o código do código da seguinte forma:
/*
* Adicione parênteses respectivamente, sem contar a chave mais externa, o primeiro parêntese esquerdo é o primeiro grupo
*/
Padrão p = Pattern.compile("(//d{3,5})([az]{2})");
String s = "123aaa-77878bb-646dd-00";
Correspondente m = p.correspondente(s);
enquanto(m.find()) {
System.out.println(m.group());
System.out.println(m.group(1));//Produz cada par de números correspondentes
System.out.println(m.group(2));//Exibe cada par de letras correspondentes
}
11. Capture e-mails de páginas da web
Copie o código do código da seguinte forma:
importar java.io.BufferedReader;
importar java.io.FileNotFoundException;
importar java.io.FileReader;
importar java.io.IOException;
importar java.util.regex.Matcher;
importar java.util.regex.Pattern;
/*
* Se você precisar de algum método de aumento, forneça primeiro o nome do método.
*Então ctrl+1 lista as recomendações e o sistema cria esse método
*/
classe pública EmailSpider {
public static void main(String[] args) {
// TODO stub de método gerado automaticamente
tentar {
BufferedReader br = new BufferedReader(new FileReader("F://regex.html"));
Linha de string = "";
tentar {
while((line=br.readLine())!=null) {
resolver(linha);
}
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
private static void resolve(linha de string) {
// TODO stub de método gerado automaticamente
//Se a expressão regular não atender à função correspondente, não ocorrerá erro porque é uma string.
Padrão p = Pattern.compile("[//w[.-]]+@[//w[.-]]+//.[//w]+");
Matcher m = p.matcher(linha);
enquanto(m.find()) {
System.out.println(m.group());
}
}
}
12. Estatísticas de código
Copie o código do código da seguinte forma:
Ver código
/*
* Conte o número de linhas em branco, linhas de comentários e linhas de programa no código
* Na verdade, você também pode usar começaCom e terminaCom em String.
* Se utilizado pelo gerente do projeto, também é necessário contar se o número de caracteres em cada linha termina com {;
*/
importar java.io.BufferedReader;
importar java.io.File;
importar java.io.FileNotFoundException;
importar java.io.FileReader;
importar java.io.IOException;
classe pública CoderCount {
normalLines longas estáticas = 0;
commentLines longos estáticos = 0;
whiteLines longos estáticos = 0;
public static void main(String[] args) {
Arquivo f = novo Arquivo("D://share//src");
Arquivo[] codeFiles = f.listFiles();
for(Arquivo filho: codeFiles){
if(child.getName().matches(".*//.java$")) {
resolver(criança);
}
}
System.out.println("normalLines:" + normalLines);
System.out.println("commentLines:" + commentLines);
System.out.println("whiteLines:" + whiteLines);
}
private static void resolve(Arquivo f) {
BufferedReader br = null;
comentário booleano = falso;
tentar {
br = novo BufferedReader(novo FileReader(f));
Linha de string = "";
while((linha = br.readLine()) != null) {
/*
* //Algumas linhas de comentários têm uma aba na frente delas
* não pode ser escrito após readLine
* A última linha será um ponteiro nulo
*/
linha = linha.trim();
//readLine remove a nova linha após ler a string.
if(line.matches("^[//s&&[^//n]]*$")) {
linhas brancas++;
} else if (line.startsWith("/*") && !line.endsWith("*/")) {
linhas de comentários++;
comentário = verdadeiro;
} else if (line.startsWith("/*") && line.endsWith("*/")) {
linhas de comentários++;
} else if (true == comentário) {
linhas de comentários++;
if(line.endsWith("*/")) {
comentário = falso;
}
} else if (line.startsWith("//")) {
linhas de comentários++;
} outro {
linhas normais++;
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finalmente {
if(br!=nulo) {
tentar {
close();
br = nulo;
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
13. Quantificadores
incluir? *+; O padrão é Ganancioso, assim como Relutante e Possessivo (exclusivo).
Copie o código do código da seguinte forma:
//O agrupamento é adicionado para vê-lo mais claramente.
Padrão p = Pattern.compile("(.{3,10})+[0-9]");
String s = "aaaa5bbbb6";//O comprimento é 10
Correspondente m = p.correspondente(s);
/*
* Agora produza 0-10, o padrão é Ganancioso, engula 10 caracteres primeiro, descubra que eles não combinam, cuspa um e descubra que eles combinam;
* Se Pattern.compile("(.{3,10}?)+[0-9]") se tornar Relutante, ele engolirá três caracteres primeiro, encontrará uma incompatibilidade, continuará engolindo até que corresponda e gerará 0 para 5;
* Se Pattern.compile("(.{3,10}++)+[0-9]") for Possessivo (exclusivo), ele também engole 10 caracteres primeiro, mas não os cospe, então não será correspondido ,
* Este método é usado principalmente onde é necessária alta eficiência (haverá erros).
*/
if(m.find()) {
System.out.println(m.start() + "----" + m.end());
}outro {
System.put.println("Não corresponde!");
}
14. Suplemento (grupo não capturador)
Copie o código do código da seguinte forma:
//O significado do grupo não capturador é oposto ao significado literal, o que significa capturar se corresponder
Padrão p = Pattern.compile("(?=a).{3}");
/*
* Saída a66, que equivale a exigir que ele comece com a. Você também pode escrever Pattern.compile("[a].{2}");
* Se Pattern.compile(".{3}(?!=a)") não terminar com {2}[^a], mas o próximo caractere não for um (lookahead), 44a, 66b será gerado, então este Este uso não é comumente usado;
* Se for Pattern.compile(".{3}(?=a)"), a saída será 444 (porque ?=a é um lookahead). , e se for colocado atrás não será incluído no grupo;
*
*
*/
Strings = "444a66b";
Correspondente m = p.correspondente(s);
enquanto(m.find()) {
System.out.println(m.group());
}
15. Referência anterior
Copie o código do código da seguinte forma:
Padrão p = Pattern.compile("(//d//d)//1");
/*
* Saída verdadeira, //1 significa igual ao primeiro grupo, estará errado se for alterado para 1213;
* Se for Pattern.compile("(//d(//d))//2"), ele precisa ser alterado para 122.
*
*/
Strings = "1212";
Correspondente m = p.correspondente(s);
System.out.println(m.matches());
16. Abreviatura de bandeiras
"." não corresponde a novas linhas, lembre-se de CASE_INSENSITIVE, a abreviatura de "correspondência sem distinção entre maiúsculas e minúsculas também pode ser habilitada por meio da expressão de sinalizador incorporada (?i)".
