Expresión regular 40

Expresión regular

  A través de una serie de análisis, se encuentra que String es un tipo muy versátil, porque String no solo admite operaciones de procesamiento de cadenas, sino que también admite la conversión a varios tipos de datos. Por lo tanto, en el desarrollo de proyectos, siempre que la información ingresada por el usuario es básicamente Ambos están representados por String. Por lo tanto, al convertir a otros tipos de datos, para asegurar la exactitud de la conversión, se requiere un proceso de verificación complejo.Es muy problemático confiar únicamente en los métodos de la clase String.

Conoce las expresiones regulares

  Supongamos que hay una cadena de caracteres y se requiere para determinar si está compuesta de números, si está compuesta de números, se convierte en un número para el cálculo de la multiplicación.
Cadena a número

public class RegexStudy {
    
    
	public static void main(String[] args) {
    
    
		String str = "1234";
		if(isNumber(str)) {
    
    
			int num = Integer.parseInt(str);
			System.err.println(num *2);
		}
	}
	public static boolean isNumber(String str) {
    
    
		char data [] = str.toCharArray();
		for (int x=0; x<data.length; x++) {
    
    
			if(data[x] >'9' || data[x]<'0') {
    
    
				return false;
			}
		}
		return true;
	}
}

De hecho, esta función de verificación es muy simple, pero requiere que los desarrolladores escriban mucho código para lograrlo. En este caso, lo mejor es usar expresiones regulares para lograr;
usa expresiones regulares para lograr

public class RegexStudy {
    
    
	public static void main(String[] args) {
    
    
		String str = "1234";
		if(str.matches("\\d+")) {
    
    
			int num = Integer.parseInt(str);
			System.out.println(num * 2);
		}
	}
}

  Las expresiones regulares se desarrollaron originalmente a partir del lenguaje Perl. Las expresiones regulares han sido compatibles desde JDK1.4, y se proporciona el kit de desarrollo java.util.regex. Al mismo tiempo, la clase String también se ha modificado para tener un método para directamente apoyarlo Procesamiento regular.
  La característica más importante de usar expresiones regulares es que es conveniente realizarProcesamiento de verificaciónY facilitar la modificación de cadenas complejas.

Marca regular de uso común (recuerde)

  Si desea realizar operaciones de procesamiento regulares, primero debe dominar las marcas regulares de uso común.A partir de JDK1.4, el kit de desarrollo java.util.regex proporciona la clase de programa Pattern, que define todas las marcas regulares admitidas.

• [Cantidad: individual] Coincidencia de caracteres:
  • Caracteres arbitrarios: significa compuesto por caracteres arbitrarios;
  • \\:partido"\";
  • \ n: coincidir con nueva línea;
  • \ t: coincide con un carácter de tabulación;
• [Cantidad: individual] Juego de caracteres coincidente (puede elegir un personaje de él)
  • [abc]: Puede ser cualquiera de las letras abc;
  • [^ abc]: ninguna de las letras abc;
  • [a-zA-Z]: consta de una letra arbitraria, no distingue entre mayúsculas y minúsculas;
  • [0-9]: significa que consta de un dígito;
• [Cantidad: Única] Conjunto de caracteres simplificado:
  • .: Representa cualquier carácter;
  • \ d: equivalente a "[0-9]";
  • \ D: equivalente a "[^ 0-9]";
  • \ s: Coincide con cualquier espacio, que puede ser un espacio, una nueva línea o un carácter de tabulación;
  • \ S: coincide con cualquier dato que no sea espacial;
  • \ w: coincide con letras, números y guiones bajos, equivalente a "[a-zA-Z_0-9]";
  • \ W: coincide con no letras, números y guiones bajos, equivalente a "[^ a-zA-Z_0-9]";
• Coincidencia de límites:
  • ^: el comienzo del límite coincidente;
  • $: inicio del límite de coincidencia;
• La cantidad significa que, de forma predeterminada, solo se puede agregar la unidad de cantidad para que coincida con varios caracteres:
  • ¿Expresión ?: Lo regular puede aparecer 0 o 1 veces;
  • Expresión *: lo regular puede aparecer 0 veces o 1 vez o varias veces;
  • Expresión +: lo regular puede aparecer 1 o más veces;
  • Expresión {n}: la longitud de la expresión es exactamente n veces;
  • Expresión {n,}: la longitud de la expresión es más de n veces;
  • Expresión {n, m}: la longitud de la expresión es n ~ m veces;
• Expresión lógica: se pueden conectar varios regulares:
  • Expresión X expresión Y: expresión X seguida inmediatamente por expresión Y;
  • Expresión X | Expresión Y: solo una expresión satisface;
  • (Expresión X): establezca una descripción general para la expresión X y puede establecer la unidad numérica para la descripción general.

Soporte de clase de cadena para regular

  En la mayoría de los casos de procesamiento de expresiones regulares, se completará en función de la clase String, y en String se proporcionan los siguientes métodos de operación relacionados con el regular:

Nombre del método	Tipos de	descripción
coincidencias booleanas públicas (String regex)	ordinario	Juzgar regularmente la cadena especificada
public String replaceAll (String regex, String reemplazo)	ordinario	Reemplaza todo
public String replaceFirst (String regex, String reemplazo)	ordinario	Reemplazar el primero
public String [] split (String regex)	ordinario	Cadena de división regular
public String [] split (String regex, int limit)	ordinario	Dividir en un número especificado

Ejemplo: reemplazo de cadena (elimine números y no letras)

public class RegexStudy {
    
    

	public static void main(String[] args) {
    
    
		String str = "SERTB4W@#$%^56Y43%$^Y3Q4$$5WERFEWG,&^LSDGPSDFG";		//要判断的数据
		String regex = "[^a-zA-Z0-9]+";		//正则表达式
		System.out.println(str.replaceAll(regex, ""));
	}
}

Ejemplo: división de cadenas

public class RegexStudy {
    
    
	public static void main(String[] args) {
    
    
		String str = "a12312312aa23423423n2bnn23n4n23";		//要判断的数据
		String regex = "\\d+";		//正则表达式
		String [] result = str.split(regex);
		for(int x=0; x<result.length; x++) {
    
    
			System.out.println(result[x]);
		}
	}
}

Es relativamente fácil de dividir y reemplazar durante el procesamiento regular, pero la parte más problemática es la parte de verificación de datos.
Ejemplo: Determine si un dato es decimal y, de ser así, cámbielo a doble.

public class RegexStudy {
    
    

	public static void main(String[] args) {
    
    
		String str = "100.32";		//要判断的数据
		String regex = "\\d+(\\.\\d+)?";		//正则表达式
		System.out.println(str.matches(regex));
	}
}

Ejemplo: Determine si una cadena se compone de fechas y, de ser así, cámbiela a Tipo de fecha.

import java.text.SimpleDateFormat;

public class RegexStudy {
    
    

	public static void main(String[] args) throws Exception {
    
    
		String str = "1981-12-12";		//要判断的数据
		String regex = "\\d{4}-\\d{2}-\\d{2}";		//正则表达式
		if(str.matches(regex)) {
    
    
			System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse(str));
		};
	}
}

Las expresiones regulares no pueden juzgar el contenido, solo el formato.
Ejemplo: determinar si el número de teléfono proporcionado es correcto

public class RegexStudy {
    
    

	public static void main(String[] args) throws Exception {
    
    
		//号码：5799033"\\d{7,8}"
		//04515799033"(\\d{3,4})?\\d{7,8}"
		//(0451)-5799033
		String str = "(0451)-5799033";		//要判断的数据
		String regex = "((\\d{3,4})|(\\(\\d{3,4}\\)-))?\\d{7,8}";		//正则表达式
		System.out.println(str.matches(regex));
	}
}

Ahora que puede utilizar las reglas habituales de verificación, puede utilizarlas para implementar una verificación de formato de dirección de correo electrónico.
Ejemplo: verificar el formato de correo electrónico

public class RegexStudy {
    
    

	public static void main(String[] args) throws Exception {
    
    
		//email用户名可以由字母、数字、_所组成(不应使用_开头)
		//email域名可以由字母、数字、_、-所组成
		//email后缀为.cn、.com、.net、.com.cn、.gov
		String str = "[email protected]";		//要判断的数据
		String regex = "[a-zA-Z0-9]\\w+@\\w+\\.(cn|com|nwt|gov|com\\.cn)";		//正则表达式
		System.out.println(str.matches(regex));
	}
}

  Ahora bien, estos tipos de operaciones de procesamiento de coincidencias regulares son el proceso más común.

Compatibilidad con el paquete java.util.regex

  Aunque puede usar la clase String para implementar operaciones regulares en la mayoría de los casos, también hay casos en los que necesita usar las clases de procesamiento regulares provistas en el kit de desarrollo java.util.regex. En esta clase se proporcionan dos clases: clase de compilación de expresiones regulares: patrón, clase de coincidencia regular: Matcher;

• La clase Pattern proporciona soporte para la compilación y procesamiento de expresiones regulares:public static Pattern compile(String regex);
  • También proporciona soporte para dividir cadenas:public String[] split(CharSequence input);

import java.util.regex.Pattern;

public class RegexStudy {
    
    

	public static void main(String[] args) throws Exception {
    
    
		String str = "adsgsdfg()2#$%^dfgh#%^DFh2345DFH@$#";		//要判断的数据
		String regex = "[^a-zA-Z0-9]+";		//正则表达式
		Pattern pat = Pattern.compile(regex);
		String reslut[] = pat.split(str);
		for(int x=0;x<reslut.length;x++) {
    
    
			System.out.println(reslut[x]);
		}
	}
}

• Clase Matcher: una clase de procesamiento que implementa la coincidencia regular. La instanciación de objetos de esta clase depende de la clase Pattern:
  • Métodos proporcionados por Pattern:public Matcher matcher(CharSequence input);
  • Después de obtener el objeto de la clase Matcher, puede utilizar los métodos de esta clase para realizar las siguientes operaciones:
    • Coincidencia regular:public boolean matches();
    • Reemplazo regular:public String replaceAll(String replacement);

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

public class RegexStudy {
    
    

	public static void main(String[] args) throws Exception {
    
    
		String str = "101";		//要判断的数据
		String regex = "\\d+";		//正则表达式
		Pattern pat = Pattern.compile(regex);
		Matcher mat = pat.matcher(str);
		System.out.println(mat.matches());
	}
}

  Si se basa puramente en las tres operaciones de dividir, reemplazar y emparejar como ejemplo, el kit de desarrollo java.utiol.regex no se usa en absoluto y solo se puede lograr confiando en la clase String. Pero hay una especie deAgrupamientoLa función de esta agrupación no está disponible en String.

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

public class RegexStudy {
    
    

	public static void main(String[] args) throws Exception {
    
    
		//要求取出“#{内容}”标记中的所有内容
		String str = "INSERT INTO dept(deptno,dname,loc) VALUES (#{deptno},#{dname},#{loc})";	//要判断的数据
		String regex = "#\\{\\w+\\}";		//正则表达式
		Pattern pat = Pattern.compile(regex);
		Matcher mat = pat.matcher(str);
		while(mat.find()) {
    
    		//是否有匹配成功的内容
			System.out.println(mat.group(0).replaceAll("#|\\{|\\}", ""));
		}
	}
}