Como todos sabemos, en el desarrollo del programa, es inevitable encontrar situaciones en las que las cuerdas deben ser emparejadas, buscadas, reemplazadas y juzgadas. Estas situaciones a veces son más complicadas. Si se resuelve en una codificación pura, a menudo desperdiciará el tiempo y la energía de los programadores. Por lo tanto, el aprendizaje y el uso de expresiones regulares se han convertido en el principal medio para resolver esta contradicción.
Como todos sabemos, las expresiones regulares son una especificación que puede usarse para la coincidencia y el reemplazo de patrones. Una expresión regular es un patrón literal compuesto por caracteres ordinarios (como los caracteres A a la Z) y los caracteres especiales (metacharacteres). Se usa para describir una o más cuerdas que se combinarán al buscar el cuerpo de un literal. La expresión regular actúa como una plantilla para que coincida con un patrón de caracteres con la cadena buscada.
Desde que JDK1.4 lanzó el paquete java.util.regex, nos ha proporcionado una buena plataforma de aplicación de expresión regular Java.
Debido a que las expresiones regulares son un sistema muy complejo, solo daré algunos ejemplos de conceptos introductorios. Para obtener más información, consulte los libros relacionados y exploro usted mismo.
// barra invernal
/t intervalo ('/u0009')
/n Line Break ('/U000A')
/r Enter ('/U000D')
/D El número es equivalente a [0-9]
/D no dígito es equivalente a [^0-9]
/s símbolo en blanco [/t/n/x0b/f/r]
/S símbolo no blancos [^/t/n/x0b/f/r]
/W Carácter individual [A-ZA-Z_0-9]
/W carácter no individual [^A-ZA-Z_0-9]
/F Page Break
/E Escape
/B el límite de una palabra
/B Un límite no palabras
/G final del partido anterior
^ Comienza con el límite
^El límite de condición de Java es a los caracteres que comienzan con Java
$ es el final del límite
Java $ Condition Limit son los caracteres Java-end
. Límites condicionales cualquier personaje excepto /N
Java .. después del límite de condición es Java, dos caracteres, excepto la nueva línea
Agregue restricciones específicas "[]"
Las condiciones [AZ] se limitan a un personaje en el rango de la A a Z.
Las condiciones [AZ] se limitan a un carácter en el rango de mayúsculas A a Z
Las condiciones [A-ZA-Z] se limitan a un carácter en el rango de la A a la Z o el rango de mayúsculas A a Z
[0-9] Las condiciones se limitan a un carácter en el rango minúscula de 0 a 9
Las condiciones [0-9A-Z] se limitan a minúsculas de 0 a 9 o A a Z rango
Las condiciones [0-9 [AZ]] se limitan al rango minúscula de 0 a 9 o A a Z (intersección)
[] y agregue la condición de restricción "[^]" nuevamente
[^AZ] Las condiciones se limitan a un carácter en el rango de no libres a a z
[^AZ] La condición limita un carácter en el rango de no cAs A a Z
[^A-ZA-Z] Las condiciones se limitan a un carácter en el rango de no-libra A a Z o mayúsculas A a Z
[^0-9] Las condiciones se limitan a un carácter en el rango de no-lowercase 0 a 9
[^0-9A-Z] Las condiciones se limitan a un carácter en el rango de no-lowercase 0 a 9 o A a Z
[^0-9 [AZ]] Las condiciones se limitan a un carácter en el rango de no-lowercase 0 a 9 o A a Z (intersección)
Cuando la condición de restricción es que un carácter específico aparece más de 0 veces, puede usar "*"
J* más de 0 j
.* Cualquier personaje por encima de 0
J.*DJ y D cualquier personaje de 0
Cuando la condición de restricción es que un carácter específico aparece más de una vez, puede usar "+"
J+ 1 o más j
.+ 1 o más caracteres arbitrarios
J.+1 o más carácter entre DJ y D
Cuando la condición de restricción es que un carácter específico aparece 0 o más veces, "?" se puede usar.
Ja? J o ja aparece
Límite a la ocurrencia continua del carácter de número especificado "{a}"
J {2} JJ
J {3} JJJ
Más que un texto, y "{a,}"
J {3,} JJJ, JJJJJ, JJJJJ, ??? (j coexist más de 3 veces)
Más de un texto, menos de B "{a, b}"
J {3,5} JJJ o JJJJ o JJJJJ
Toma uno de los dos
J | aj o un
Java | Hola Java o hola
"()" especifica un tipo de combinación, por ejemplo, si consulto los datos entre <a href =/"index.html/"> index </a>, puedo escribir <a.*href =/".*/"> (.+?) </a>
Al usar la función Pattern.Compile, puede agregar parámetros que controlan el comportamiento coincidente de las expresiones regulares:
Pattern Pattern.Compile (String Regex, Int Flag)
El rango de valores de las banderas es el siguiente:
Patrón.canon_eq La coincidencia se determina si y solo si la "descomposición canónica" de los dos caracteres es exactamente lo mismo. Por ejemplo, después de usar esta bandera, la expresión "A/U030A" coincidirá "?". Por defecto, no se considera la "igualdad canónica".
Pattern.case_insensitive (? I) Por defecto, la coincidencia de casos no identificados solo está disponible para conjuntos de caracteres US-ASCII. Este indicador permite que las expresiones ignoren el caso para la coincidencia. Para que coincida con los caracteres Unicode con un tamaño desconocido, simplemente combine unicode_case con este indicador.
Pattern.comments (? X) En este modo, los caracteres espaciales (en expresiones regulares) se ignorarán al coincidir (nota del traductor: no se refiere a "// s" en la expresión, pero se refiere a espacios, pestañas, retorno de carro, etc.) en la expresión. Los comentarios comienzan en # y terminan en esta línea. El modo de fila UNIX se puede habilitar a través de banderas incrustadas.
Pattern.dotall (? S) En este modo, la expresión '.' puede coincidir con cualquier personaje, incluido el personaje final que representa una línea. Por defecto, la expresión '.' no coincide con el carácter final de la línea.
Patrón.multilina
(? M) En este modo, '^' y '$' coinciden con el principio y el final de una fila respectivamente. Además, '^' todavía coincide con el comienzo de la cadena, y '$' también coincide con el final de la cadena. Por defecto, estas dos expresiones solo coinciden con el principio y el final de la cadena.
Pattern.unicode_case
(? U) En este modo, si también habilita el indicador Case_insensitive, coincidirá con los caracteres Unicode con un caso no identificado. Por defecto, la coincidencia insensible al caso solo está disponible para conjuntos de caracteres US-ASCII.
Pattern.unix_lines (? D) En este modo, solo '/n' se considera un aborto de una línea y coincide '.', '^' Y '$'.
Dejando de lado el concepto vacío, aquí hay algunos casos de uso regulares simples de Java:
◆ Por ejemplo, cuando la cadena contiene verificación
// Encuentra una cadena que comience con Java y termina a Will Pattern Pattern = Pattern.Compile ("^Java.*"); Matcher Matcher = Pattern.Matcher ("Java no es un humano"); booleano b = matcher.matches (); // Cuando se satisface la condición, devolverá verdadero, de lo contrario falso System.out.println (b); ◆ Al dividir las cadenas con múltiples condiciones
Pattern Pattern = Pattern.Compile ("[, |]+"); String [] strs = Pattern.split ("Java Hello World Java, Hello ,, World | Sun"); para (int i = 0; i <strs.length; i ++) {System.out.println (strs [i]);} ◆ Reemplazo de texto (el carácter aparece por primera vez)
Pattern Pattern = Pattern.Compile ("Expresión regular"); Matcher Matcher = Pattern.Matcher ("Expresión regular Hello World, expresión regular Hello World"); // Reemplazar los primeros datos que cumplen con el regularity System.out.println (matcher.replaceFirst ("java")); ◆ Reemplazo de texto (todos)
Pattern Pattern = Pattern.Compile ("Expresión regular"); Matcher Matcher = Pattern.Matcher ("Expresión regular Hello World, Regular Expression Hello World"); // Reemplace los primeros datos que cumplen con el regularity System.out.println (matcher.replaceall ("java")); ◆ Reemplazo de texto (reemplazar caracteres)
Pattern Pattern = Pattern.Compile ("Expresión regular"); matcher matcher = patrón.matcher ("Expresión regular Hello World, Expresión regular Hello World"); StringBuffer SBR = new StringBuffer (); while (matcher.find ()) {matcher.appendreplacation (sbr, "java");} matcher.appendtail (sbr); system.out.println (sbr.ToString ());◆ Verifique si se trata de una dirección de correo electrónico
String str = "[email protected]"; patrones = patrón.compile ("[// w //.//-font>+@(ículo// w //-font>+///.)+che// w //-]+", patrones.case_insensitive); matcher = patrones.matcher (str); system.out.println (matcher.matches ());
◆ Eliminar etiquetas HTML
Pattern Pattern = Pattern.Compile ("<.+?>", Pattern.dotall); matcher matcher = patrón.matcher ("<a href =/" index.html/"> home </a>"); string string = matcher.replaceall (""); system.out.println (string); ◆ Encuentre la cadena de condición correspondiente en HTML
Pattern Pattern = Pattern.Compile ("href =/" (.+?)/""); Matcher matcher = patrón.matcher ("<a href =/" index.html/"> home </a>"); if (matcher.find ()) system.out.println (matcher.group (1));} ◆ Intercept http: // dirección
// Intercept UrlPattern Pattern = Pattern.Compile ("(http: // | https: //) {1} [//w/.//-/:]+"); matcher matcher = patrón.matcher ("dsdsds <http: // dsds // gfgffdfd> fdf"); stringbuffer buffer = niewbuffer (); while (matcher.find ()) {buffer.append (matcher.group ()); buffer.append ("/r/n"); System.out.println (buffer.toString ());}◆ Reemplace los caracteres chinos especificados {}
String Str = "El historial de desarrollo actual de Java es de {0} años - {1} años"; string [] [] objeto = {new String [] {"// {0 ///}", "1995"}, new String [] {"// {1 //}", "2007"}}}; system.println (reemplazo (reemplazar (reemplazar (reemplazo); SourCeString, Object [] Object) {String temp = SourCeString; for (int i = 0; i <object.length; i ++) {string [] result = (string []) objeto [i]; Patrón patrón = patrón.compile (resultado [0]); Matcher Matcher = Pattern.Matcher (temp); temp = matcher.replaceall (resultado [1]); } return temp;}◆ Archivos de consulta en directorios designados con condiciones regulares
// se usa para almacenar en caché de archivos de arrayList private = new ArrayList (); // utilizado para alojar el archivo ruta de cadena privada _path; // se usa para alojar fórmula regular inminente cadena privada _regexp; clase MyFileFilter implementa FileFilter { / *** Match File Name* / public boolean Acept (archivo de archivo) {try {patrón patrón = patrón.compile (_regexp); Matcher Match = Pattern.Matcher (file.getName ()); return match.matches (); } capt (excepción e) {return true; }}} / *** Analice la transmisión de entrada* @param entradas* / filesanalyze (string ruta, cadena regexp) {getFileName (ruta, regexp); } /** * Analice el nombre del archivo y agregue archivos * @param entrada * /private void getFileName (string path, string regexp) {// directorio_path = path; _regexp = regexp; Directorio de archivos = nuevo archivo (_path); File [] filesfile = directorio.listFiles (new MyFileFilter ()); if (filesfile == null) return; for (int j = 0; j <filesfile.length; j ++) {files.add (filesfile [j]); } devolver; } / *** Mostrar información de salida* @param out* / public void print (printstream out) {iterator elements = files.iterator (); while (elements.hasnext ()) {file file = (file) elements.next (); out.println (file.getpath ()); }} Public static void output (string ruta, string regexp) {filesAnalyze FileGroup1 = new FilesAnalyze (Path, Regexp); FileGroup1.print (System.out); } public static void main (string [] args) {output ("c: //", "[az |.]*"); }Hay muchas funciones de regularidad de Java. De hecho, siempre que sea el procesamiento de personajes, no hay nada que la regularidad no pueda hacer. (Por supuesto, lleva mucho tiempo explicarlo regularmente ||| ...)
Lo anterior es la información que clasifica las expresiones regulares de Java. Continuaremos agregando información relevante en el futuro. ¡Gracias por su apoyo para este sitio!