1. expresión regular (expresión regular): RegularExpressions (que reemplaza a StringTokenizer); una poderosa herramienta para el procesamiento de cadenas, popular en Unix, Perl es aún mejor usando expresiones regulares.
Se utiliza principalmente en la coincidencia, búsqueda y reemplazo de cadenas. Por ejemplo: hacer coincidir IP (rango inferior a 256) es fácil de usar con expresiones regulares; extraer una gran cantidad de direcciones de correo electrónico de páginas web para enviar spam; Contiene Matcher (el resultado de hacer coincidir una cadena con un patrón) y un patrón.
Copie el código de código de la siguiente manera:
/*
* Indica si esta cadena coincide con la expresión regular dada (también una cadena).
*/
System.out.println("abc".matches("..."));//Cada "."
Copie el código de código de la siguiente manera:
/*
* Reemplace todos los números en la cadena con "-". El método ordinario requiere que charAt se juzgue uno por uno;
* "//d" representa cualquier número o reemplácelo con "[0-9]";
* "//D" representa cualquier número que no sea un dígito o se reemplaza con "[^0-9]"
*/
System.out.println("ab54564654sbg48746bshj".replaceAll("[0-9]", "-"));//Cada "."
dos,
Copie el código de código de la siguiente manera:
/*
* compilar compila la expresión regular dada en el patrón (cada compilación lleva tiempo; {3} significa exactamente tres veces);
* X{n} X, exactamente n veces
* X{n,} X, al menos n veces
* X{n,m} X, al menos n veces, pero no más de m veces
*/
Patrón p = Pattern.compile("[az]{3}");
Matcher m = p.matcher("ggs");//Crea un comparador que haga coincidir la entrada dada con este patrón. Internamente, se crea un autómata de estado prioritario (principio de compilación)
// La cadena que se comparará en el comparador y las coincidencias es en realidad CharSequence (interfaz), pero String implementa esta interfaz y tiene polimorfismo
System.out.println(m.matches());//Si es "ggss", no coincidirá
// Siempre puedes "ggs".matches("[az]{3}") directamente, pero lo anterior tiene ventajas, al menos es más eficiente, y Pattern y Matcher proporcionan muchas funciones.
3. Llame al metacarácter en la expresión regular ". * +"; ctrl + shift + "/" significa comentario, reemplácelo con "/" para eliminar el comentario.
Copie el código de código de la siguiente manera:
"a".matches(".");//true, "." representa cualquier carácter, incluidos los caracteres chinos
"aa".matches("aa");//verdadero, es decir, las cadenas ordinarias también se pueden utilizar como expresiones regulares
/*
* verdadero, "*" significa 0 o más caracteres, pero los siguientes caracteres deben ser iguales que el primero.
* De lo contrario, es falso, es decir, se juzga si la cadena es una cadena compuesta de caracteres individuales.
*/
"aaaa".matches("a*");
"".matches("a*");//verdadero
"aaa".matches("a?");//verdadero, una o 0 veces
"".matches("a?");//verdadero
"a".matches("a?");//verdadero
"544848154564113".matches("//d{3,100}");//verdadero
// Este es el juicio de IP más simple, pero si excede 255, no se puede juzgar.
"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 coincidir con cualquier carácter; [^abc] significa un carácter distinto de abc (debe ser una letra y se devolverá falso si es una cadena vacía) es equivalente a [a-zA-Z]); "[az ]|[AZ]" es una determinada letra mayúscula o minúscula; [AZ&&[ABS]] significa cualquiera de las letras mayúsculas y ABS.
Copie el código de código de la siguiente manera:
// Descubrí que no hay diferencia entre | y ||, pero sí hay diferencia entre & y &&.
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]]"));//verdadero
System.out.println("C".matches("[AZ||[ABS]]"));//verdadero
5. /w caracteres de palabra: [a-zA-Z_0-9] cuando coincidan con nombres de usuario; /s caracteres en blanco: [ /t/n/x0B/f/r] /S caracteres que no estén en blanco: [^/s] ] ;/W caracteres que no son palabras: [^/w].
Copie el código de código de la siguiente manera:
" /n/t/r".matches("//s{4}");//verdadero
" ".matches("//S");//falso
"a_8".matches("//w{3}");//verdadero
//"+" significa una o varias veces
"abc888&^%".matches("[az]{1,3}//d+[&^#%]+");//verdadero
/*
* El carácter que debe coincidir es solo una barra invertida, pero no se puede escribir como "/" y luego combinarlo con lo siguiente ",
*El anterior "no puede coincidir" dará lugar a CE.
* no puede ir seguido de "//", de lo contrario se producirá un error de tiempo de ejecución (no hay problema en la compilación), debe escribirse como "////"
*/
System.out.println("//".matches("////"));//verdadero
6. Clase de caracteres POSIX (solo US-ASCII)
Copie el código de código de la siguiente manera:
/p{Lower} Caracteres alfabéticos en minúsculas: [az] ;/p{Upper} Caracteres alfabéticos en mayúsculas: [AZ] ;/p{ASCII} Todo ASCII: [/x00-/x7F] ;/p{Alpha} Caracteres alfabéticos: [/p{Lower}/p{Upper}] ;/p{Digit} Número decimal: [0-9].
7. Igualador de límites
^ Principio de línea $ Fin de línea/b Límite de palabra/B Límite sin palabra/A Inicio de entrada/G Fin de coincidencia anterior/Z Fin de entrada, solo se usa para el último terminador (si corresponde)
/z fin de la entrada
Copie el código de código de la siguiente manera:
"hello world".matches("^h.*");//El comienzo de la línea ^
"hola mundo".matches(".*ld$");//Fin de $línea
"hola mundo".matches("^h[az]{1,3}o//b.*");///bword limite
"holamundo".matches("^h[az]{1,3}o//b.*");
" /n".matches("^[//s&&[^//n]]*//n$");//Juzga las líneas en blanco, que comienzan con un carácter en blanco
8. También puede usar m.start() y m.end() en el método de búsqueda para devolver el siguiente entre la posición inicial y la posición final, si no se puede encontrar, se producirá un error;
Copie el código de código de la siguiente manera:
Patrón p = Pattern.compile("//d{3,5}");
Cadena s = "133-34444-333-00";
Emparejador m = p.matcher(s);
m.matches();//matches coincide con todas las cadenas
m.reset();
/*
* Si el método de reinicio se llama primero a continuación, se generará verdadero, verdadero, verdadero, falso.
* De lo contrario, el penúltimo hallazgo también genera falso.
*Las razones son las siguientes:
* coincide con el primer "-" y descubre que no coincide, pero estos cuatro caracteres se han comido. La combinación nuevamente comenzará desde.
* 34444 comienza y la segunda búsqueda comienza en 333, porque la búsqueda coincide con la siguiente subsecuencia.
* El método de reinicio permite que las cerillas escupan el hilo comido por las cerillas.
* En resumen: se debe usar reset entre coincidencias y búsqueda, porque se afectan entre sí
*
*/
m.buscar();
m.buscar();
m.find();//Intenta encontrar la siguiente subsecuencia de la secuencia de entrada que coincida con este patrón
m.buscar();
/*
* Intenta hacer coincidir una secuencia de entrada que comienza al principio de la región con este patrón.
* El autor de Thinking in Java criticó severamente este método porque no queda claro en las palabras dónde empezar a hacer coincidir.
* Todo lo siguiente es cierto, porque siempre empiezan desde cero.
*/
m.mirandoA();
m.mirandoA();
m.mirandoA();
m.mirandoA();
9. Reemplazo de cuerdas
Copie el código de código de la siguiente manera:
importar java.util.regex.Matcher;
importar java.util.regex.Pattern;
clase pública TestRegexReplacement {
público estático vacío principal (String [] argumentos) {
Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//El siguiente parámetro es un número entero, lo que significa "no distingue entre mayúsculas y minúsculas"
Matcher m = p.matcher("Java java hxsyl Ilovejava java JaVaAcmer");
while(m.buscar()) {
System.out.println(m.group());//m.group generará todo Java (ignorando mayúsculas y minúsculas)
}
String s = m.replaceAll("Java");//String también tiene este método
System.out.println(s);
m.reset();//debe agregarse porque buscar y comparar se afectan entre sí
StringBuffer sb = nuevo StringBuffer();
int yo = 0;
/*
* El siguiente método consiste en reemplazar el número impar de java encontrado por "Java" y el número par por "java"
*/
while(m.buscar()) {
yo ++;
//No se puede escribir directamente como i&1 y se debe convertir a booleano
si((i&1)==1) {
m.appendReplacement(sb, "Java");
}demás {
m.appendReplacement(sb, "java");
}
}
m.appendTail(sb);//Agrega la cadena restante después del último java encontrado
System.out.println(sb);// Sin reinicio, solo se genera Acmer
}
}
10. Agrupación
Copie el código de código de la siguiente manera:
/*
* Agregue paréntesis respectivamente, sin contar la llave más externa, el primer paréntesis izquierdo es el primer grupo
*/
Patrón p = Pattern.compile("(//d{3,5})([az]{2})");
Cadena s = "123aaa-77878bb-646dd-00";
Emparejador m = p.matcher(s);
while(m.buscar()) {
System.out.println(m.group());
System.out.println(m.group(1));// Genera cada par de números coincidentes
System.out.println(m.group(2));//Envía cada par de letras coincidentes
}
11. Capture correos electrónicos de páginas web
Copie el código de código de la siguiente manera:
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;
/*
* Si necesita algún método de recaudación, proporcione primero el nombre del método.
* Luego Ctrl + 1 enumera las recomendaciones y el sistema crea este método.
*/
clase pública EmailSpider {
público estático vacío principal (String [] argumentos) {
// TODO Código auxiliar de método generado automáticamente
intentar {
BufferedReader br = nuevo BufferedReader(nuevo FileReader("F://regex.html"));
Línea de cadena = "";
intentar {
while((linea=br.readLine())!=null) {
resolver(línea);
}
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
} captura (FileNotFoundException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
resolución de vacío estático privado (línea de cadena) {
// TODO Código auxiliar de método generado automáticamente
//Si la expresión regular no cumple con la función correspondiente, no cometerá error porque es una cadena.
Patrón p = Pattern.compile("[//w[.-]]+@[//w[.-]]+//.[//w]+");
Emparejador m = p.matcher(línea);
while(m.buscar()) {
System.out.println(m.group());
}
}
}
12. Estadísticas de código
Copie el código de código de la siguiente manera:
Ver código
/*
* Cuente el número de líneas en blanco, líneas de comentarios y líneas de programa en el código
* De hecho, también puedes usar comienza con y termina con en cadena.
* Si lo utiliza el director del proyecto, también es necesario contar si el número de caracteres en cada línea termina en {;
*/
importar java.io.BufferedReader;
importar java.io.File;
importar java.io.FileNotFoundException;
importar java.io.FileReader;
importar java.io.IOException;
clase pública CoderCount {
líneas normales largas estáticas = 0;
líneas de comentarios largas estáticas = 0;
líneas blancas largas estáticas = 0;
público estático vacío principal (String [] argumentos) {
Archivo f = nuevo archivo("D://share//src");
Archivo[] codeFiles = f.listFiles();
para(Archivo secundario: codeFiles){
if(child.getName().matches(".*//.java$")) {
resolver(niño);
}
}
System.out.println("Líneas normales:" + Líneas normales);
System.out.println("líneas de comentarios:" + líneas de comentarios);
System.out.println ("líneas blancas:" + líneas blancas);
}
resolución de vacío estático privado (archivo f) {
BufferedReader br = nulo;
comentario booleano = falso;
intentar {
br = nuevo BufferedReader(nuevo FileReader(f));
Línea de cadena = "";
while((línea = br.readLine()) != nulo) {
/*
* //Algunas líneas de comentarios tienen una pestaña delante
* no se puede escribir después de readLine
* La última línea será un puntero nulo.
*/
línea = línea.trim();
//readLine elimina la nueva línea después de leer la cadena.
if(line.matches("^[//s&&[^//n]]*$")) {
líneas blancas++;
} else if (line.startsWith("/*") && !line.endsWith("*/")) {
líneas de comentarios++;
comentario = verdadero;
} else if (line.startsWith("/*") && line.endsWith("*/")) {
líneas de comentarios++;
} más si (verdadero == comentario) {
líneas de comentarios++;
if(line.endsWith("*/")) {
comentario = falso;
}
} más si (line.startsWith("//")) {
líneas de comentarios++;
} demás {
líneas normales++;
}
}
} captura (FileNotFoundException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
} finalmente {
si(br!= nulo) {
intentar {
br.cerrar();
br = nulo;
} captura (IOException e) {
e.printStackTrace();
}
}
}
}
}
13. Cuantificadores
¿incluir? *+; El valor predeterminado es Codicioso, así como Reacio y Posesivo (exclusivo).
Copie el código de código de la siguiente manera:
//Se agrega la agrupación para verlo más claro.
Patrón p = Patrón.compile("(.{3,10})+[0-9]");
String s = "aaaa5bbbb6";//La longitud es 10
Emparejador m = p.matcher(s);
/*
* Ahora genera 0-10, el valor predeterminado es Codicioso, primero trague 10 caracteres, descubra que no coinciden, escupa uno y descubra que coinciden;
* Si Pattern.compile("(.{3,10}?)+[0-9]") se vuelve reacio, primero tragará tres caracteres, encontrará una discrepancia, continuará tragando hasta que coincida y generará 0 a 5;
* Si Pattern.compile("(.{3,10}++)+[0-9]") es Posesivo (exclusivo), también traga 10 caracteres primero, pero no los escupe, entonces no coincidirá ,
* Este método se utiliza principalmente cuando se requiere alta eficiencia (habrá errores).
*/
if(m.buscar()) {
System.out.println(m.start() + "----" + m.end());
}demás {
System.put.println("¡No coincide!");
}
14. Suplemento (grupo no captador)
Copie el código de código de la siguiente manera:
// El significado del grupo que no captura es opuesto al significado literal, es decir, capturar si coincide
Patrón p = Pattern.compile("(?=a).{3}");
/*
* Genera a66, lo que equivale a requerir que comience con a. También puedes escribir Pattern.compile("[a].{2}");
* Si Pattern.compile(".{3}(?!=a)") no termina con {2}[^a], pero el siguiente carácter no es un (lookahead), se generarán 44a, 66b, entonces este uso no se usa comúnmente;
* Si es Pattern.compile(".{3}(?=a)"), generará 444 (porque ?=a es una anticipación. Si se coloca al frente, se incluirá en el grupo). , y si se coloca atrás no se incluirá en el grupo;
*
*
*/
Cadena s = "444a66b";
Emparejador m = p.matcher(s);
while(m.buscar()) {
System.out.println(m.group());
}
15. Referencia posterior
Copie el código de código de la siguiente manera:
Patrón p = Pattern.compile("(//d//d)//1");
/*
* Salida verdadera, //1 significa lo mismo que el primer grupo, será incorrecto si se cambia a 1213;
* Si es Pattern.compile("(//d(//d))//2"), debe cambiarse a 122.
*
*/
Cadena s = "1212";
Emparejador m = p.matcher(s);
System.out.println(m.matches());
16. Abreviatura de banderas
"." no coincide con las nuevas líneas, solo recuerde CASE_INSENSITIVE, la abreviatura de "la coincidencia que no distingue entre mayúsculas y minúsculas también se puede habilitar mediante la expresión de indicador incrustada (?i)".
