Resumen de aprendizaje de Java: 38 (expresión regular)

Expresión regular

Las expresiones regulares son esencialmente una regla gramatical para las operaciones de cadenas, con lo cual podemos implementar de manera más flexible las operaciones de coincidencia, división y reemplazo de cadenas.

Marca regular

Todas las clases soportadas por expresiones regulares se definen en el paquete java.util.regex. Las siguientes dos clases principales se definen en este paquete:
1. Clase de patrón: define principalmente el objeto de expresión que se utilizará.
2. Clase Matcher: se utiliza para realizar la operación de correspondencia de etiquetas regulares y contenido especificado.

Todas las etiquetas regulares que se pueden usar se definen en el documento de descripción de clase java.util.regex.Pattern. Las etiquetas que se usan comúnmente son las siguientes:

1. Carácter individual (número: 1)

• Carácter: indica que consta de un personaje;
• \\\: indica el carácter de escape "\";
• \ t: representa un símbolo "\ t";
• \ n: representa un símbolo "\ n";

2. Juego de caracteres (cantidad: 1)

• [abc]: indica que puede ser cualquiera de los caracteres a, b y c;
• [^ abc]: No es ninguno de los caracteres a, b, c;
• [az]: todas las letras minúsculas;
• [a-zA-Z]: representa una letra arbitraria, no distingue entre mayúsculas y minúsculas;
• [0-9]: Representa cualquier dígito arbitrario;

3. Expresión simplificada del juego de caracteres (cantidad: 1)

• .: Representa un carácter arbitrario;
• \ d: equivalente a "[0-9]", que pertenece a la escritura simplificada;
• \ D: equivalente a "[^ 0-9]", que pertenece a la escritura simplificada;
• \ s: representa los caracteres en blanco, por ejemplo: "\ t", "\ n";
• \ S: representa cualquier carácter de espacio no blanco;
• \ w: equivalente a "[a-zA-Z_0-9]", lo que significa que consiste en cualquier letra, número, _;
• \ W: equivalente a "[a-zA-Z_0-9]", lo que indica que no está compuesto de letras arbitrarias, números, _;

4. Asignación de límites

• ^: Inicio regular;
• $: Final regular;

5. Expresión cuantitativa

• Regular?: Indica que este regular puede aparecer 0 o 1 veces;
• Regular +: indica que este regular puede aparecer una vez o más de una vez;
• Regular *: indica que este regular puede aparecer 0 veces, 1 vez o varias veces;
• Regular {n}: indica que este regular aparece exactamente n veces;
• Regular {n,}: indica que este regular aparece más de n veces (incluidas n veces);
• Regular {n, m}: indica que este regular aparece n ~ m veces;

6. Operación lógica

• Regular 1 Regular 2: Regular 1 continúa juzgando a regular 2 después de que se completa el juicio;
• Regular 1 | Regular 2: Regular 1 o regular 2 pueden ser satisfechos;
• (Regular): tome varios clientes habituales como grupo, puede establecer el número de ocurrencias para este grupo por separado.

Métodos comunes de patrón

No.	Nombre del método	Tipo	Descripción
1	compilación pública de patrones estáticos (expresiones regulares de cadena)	Ordinario	Compilar expresiones regulares
2	división de cadena pública [] (entrada de secuencia de caracteres)	Ordinario	Operación de división de datos completa
3	división de cadena pública [] (entrada de secuencia de caracteres, límite int)	Ordinario	Operación de división de datos
4 4	Matcher público Matcher (entrada de secuencia de caracteres)	Ordinario	Obtener objeto de clase Matcher

Nota: La clase Patrón no define un método de construcción, por lo que si desea obtener el objeto de la clase Patrón, debe usar el método compile () para compilar la expresión regular. Al mismo tiempo, debido a que los métodos definidos en la clase Patrón reciben objetos de la interfaz CharSequence cuando reciben parámetros, cualquier subclase de la interfaz CharSequence puede realizar operaciones regulares.

Ejemplo: use la clase Patrón para lograr la división de cadenas

package Project.Study.PatternClass;

import java.util.Arrays;
import java.util.regex.Pattern;

public class Test1 {
    public static void main(String[]args){
        String str="hello3232world32!!!";
        String regex="\\d+";
        Pattern pattern=Pattern.compile(regex);		//编译正则
        String[] result =pattern.split(str);		//拆分字符串
        System.out.println(Arrays.toString(result));
    }
}
//结果：
//[hello, world, !!!]

Métodos comunes de la clase Matcher.

No.	Nombre del método	Tipo	Descripción
1	partidos booleanos públicos ()	Ordinario	Partido regular
2	Cadena pública replaceAll (Reemplazo de cadena)	Ordinario	Reemplazar todo
3	Cadena pública replaceFirst (Reemplazo de cadena)	Ordinario	Reemplazar el primero

Ejemplo: Implementar operación de verificación de cadena

package Project.Study.MatcherClass;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test1 {
    public static void main(String[]args){
        String str="100";
        String regex="\\d+";
        Pattern pattern=Pattern.compile(regex);	//编译正则
        Matcher matcher=pattern.matcher(str);	//进行正则匹配
        System.out.println(matcher.matches());	//匹配结果
    }
}
//结果：
//true

Soporte de clase de cadena para regular

De hecho, en el desarrollo real, la clase String se usa más. En la mayoría de los casos, los métodos proporcionados en la clase String se usarán para simplificar directamente la operación regular. Solo en casos raros se usarán las clases Pattern y Matcher para operar la regularidad.

Cinco métodos de operación relacionados con la regularidad en la clase String

No.	Nombre del método	Tipo	Descripción
1	coincidencias booleanas públicas (expresión regular de cadena)	Ordinario	Verificación regular, use la cadena especificada para determinar si cumple con la estructura de expresión regular dada
2	Cadena pública replaceAll (expresión de cadena, reemplazo de cadena)	Ordinario	Reemplace todo el contenido que cumpla con la marca regular con contenido nuevo
3	cadena pública replaceFirst (expresión regular de cadena, reemplazo de cadena)	Ordinario	Reemplace el primer contenido que cumpla con la marca regular con contenido nuevo
4 4	división pública de cadena [] (expresión regular de cadena)	Ordinario	Realizar una división de cadena completa de acuerdo con la marca regular especificada
5 5	división pública de la cadena [] (expresión regular de la cadena, límite interno)	Ordinario	Partir parcialmente la cadena de acuerdo con la marca regular especificada

Los cinco métodos anteriores incluyen operaciones de reemplazo, división y verificación de cadenas. Implementemos

Ejemplo: implementar reemplazo de cadena

package Project.Study.Regex;

public class Test1 {
    public static void main(String[]args){
        String str="hel12l32o232121wQo@#rl32d!!!";//给出一组混乱的字符串
        String regex="[^a-z]";		//编写正则，剔除所有不是小写字母的字符
        System.out.println(str.replaceAll(regex,""));//字符串替换
    }
}
//结果：
//helloworld

Ejemplo: división de cadenas

package Project.Study.Regex;

public class Test2 {
    public static void main(String[]args){
        String str="hello090world3241!!!";
        String regex="\\d+";	//表示"[0-9]"一位以上的整数位，属于简化写法，因为是在字符串中定义的，所以用"\\"代替"\"，属于转义字符操作
        String[] result =str.split(regex);
        for (String s : result) {
            System.out.println(s);	//输出分隔好的字符串
        }
    }
}
//结果：
//hello
//world
//!!!

Solicitud de verificación regular

Si la cadena es un número con un punto decimal "." (Punto decimal "." Significa cualquier carácter en el regular), ¿cómo debemos convertirlo en datos de coma flotante?
Ejemplo: convertir números de caracteres a datos de coma flotante

package Project.Study.Regex;

public class Test3 {
    public static void main(String[]args){
        String str1="10.01";
        String str2="10.10";
        String regex="\\d+(\\.\\d+)?";
        if(str1.matches(regex)){		//转型前要进行验证
            System.out.println(Double.parseDouble(str1));
        }
        if(str2.matches(regex)){		//转型前要进行验证
            System.out.println(Double.parseDouble(str2));
        }
    }
}
//结果：
//10.01
//10.1

Análisis regular en el

programa anterior : "?" En el programa anterior indica que el lugar decimal puede aparecer 0 o 1 veces.
El método match () se usa en el programa anterior para la verificación regular. De manera similar, también podemos usarlo para juzgar a otros, como: dirección IP

Ejemplo:

package Project.Study.Regex;

public class Test4 {
    public static void main(String[]args){
        String str1="192.168.1.1";
        String str2="192.1683.1.1";
        String regex1="\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}";//该正则中的"\\d{1,3}"表示1~3位数字
        String regex2="(\\d{1,3}\\.){3}\\d{1,3}";		//简化正则操作
        System.out.println(str1.matches(regex1));
        System.out.println(str1.matches(regex2));
        System.out.println(str2.matches(regex1));
        System.out.println(str2.matches(regex2));
    }
}

//结果：
//true
//true
//false
//false

Ejemplo: determinar si el formato de fecha es correcto

package Project.Study.Regex;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test5 {
    public static void main(String[]args) throws ParseException {
        String str="2013-8-15";
        String regex="\\d{4}-\\d{1,2}-\\d{1,2}";	//定义验证正则
        if(str.matches(regex)){						//符合规则
            Date date=new SimpleDateFormat("yyyy-MM-dd").parse(str);
            System.out.println(date);
        }
    }
}
//结果：
//Thu Aug 15 00:00:00 CST 2013