La extracción o validación de datos es un aspecto importante de todos los lenguajes de programación. Una de las formas más populares de validación de datos es mediante el uso de expresiones regulares. usa estosexpresiones regulares para describir un patrón de caracteres. Este artículo sobre Java Regex enumerará los diversos métodos de uso de expresiones en la siguiente secuencia:
- ¿Qué son las expresiones regulares?
- ¿Qué es Java Regex?
- Clase Matcher
- Clase de patrón
- Clase de personaje Regex
- Cuantificadores de expresiones regulares
- Metacaracteres Regex
¡Empecemos!
¿Qué son las expresiones regulares?
A Expresión regular es una secuencia de caracteres que construye un patrón de búsqueda. Cuando busca datos en un texto, puede utilizar este patrón de búsqueda para describir lo que está buscando.
Una expresión regular puede ser una carácter único o un patrón más complicado. Se puede utilizar para cualquier tipo de búsqueda de texto y operaciones de reemplazo de texto. Un patrón Regex consta de caracteres simples, como /abc/ , o una combinación de caracteres simples y especiales, como /a B C/ o /example(d+).d*/ .
¿Qué es Java Regex?
los Java Regex es una API que se utiliza para definir un patrón para buscar o manipular . Se usa ampliamente para definir la restricción en cadenas, como la validación de contraseña y correo electrónico.
Existen diferentes métodos para usar Java Regex. Así que sigamos adelante y echemos un vistazo a las diferentes expresiones.
Clase Matcher
Esta clase se utiliza para realizar operaciones de coincidencia en una secuencia de caracteres. La siguiente tabla representa varios métodos de la clase Matcher.
encontrar el número más grande en una matriz java
| Método | Descripción |
|---|---|
| coincidencias booleanas () | Comprueba si la expresión regular dada coincide con el patrón |
| buscar booleano () | Se usa para encontrar la siguiente expresión que coincide con el patrón |
| búsqueda booleana (inicio int) | Busca la siguiente expresión que coincida con el patrón desde el número de inicio dado |
| Grupo de cadenas () | Se usa para devolver la subsecuencia coincidente |
| int start () | Devuelve el índice inicial de la subsecuencia coincidente |
| int end () | Devuelve el índice final de la subsecuencia coincidente |
| int groupCount () | Devuelve el número total de la subsecuencia coincidente |
Clase de patrón
Pattern Class es una versión compilada de una expresión regular que se utiliza para definir el patrón del motor de expresiones regulares.
| Método | Descripción |
|---|---|
| compilación de patrones estáticos (String regex) | Compila la expresión regular dada y devuelve la instancia del Patrón |
| Coincide con coincidencias (entrada CharSequence) | Se utiliza para crear un comparador que coincide con la entrada dada con el patrón. |
| Coincidencias booleanas estáticas (String regex, entrada CharSequence) | Funciona como una combinación de métodos de compilación y comparación. Compila la expresión regular y hace coincidir la entrada dada con el patrón |
| Cadena [] dividida (entrada CharSequence) | Se usa para dividir la cadena de entrada dada alrededor de coincidencias de un patrón dado |
| Patrón de cuerdas() | Ayuda a devolver el patrón de expresiones regulares |
Ahora tomemos un pequeño ejemplo para entender cómo escribir una expresión regular.
import java.util.regex. * public class RegexExample {public static void main (String [] args) {Pattern pattern = Pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('String coincide con el Regex dado - + matcher.matches ())}}En este caso, internamente usa Pattern y Matcher clases de expresiones regulares para hacer el procesamiento, pero obviamente,reduce las líneas de código. La clase de patrón también contiene un método de coincidencias que toma la expresión regular y la cadena de entrada como argumento y devuelve un resultado booleano después de hacer coincidirlos. Entonces el código funciona bien para la entrada coincidente con una expresión regular en Java. Por lo tanto, la salida será verdadera como se muestra a continuación.
Salida:
cierto
Ahora veamos algunas categorías más de expresiones regulares de Java.
Clase de personaje Regex
La siguiente tabla representa las diferentes combinaciones de clases de caracteres.
| Clase de personaje | Descripción |
|---|---|
| [abc] | a, b o c (clase simple) |
| [^abc] | Cualquier carácter excepto a, b o c (negación) |
| [a-zA-Z] | de la a a la zo de la A a la Z, inclusive (rango) |
| [a-d [m-p]] | a hasta d, om hasta p: [a-dm-p] (unión) |
| [a-z && [def]] | d, e o f (intersección) |
| [a-z && [^ bc]] | de la a a la z, excepto b y c: [ad-z] (resta) |
| [a-z && [^ m-p]] | de la a a la z, y no de la m a la p: [a-lq-z] (resta) |
Ejemplo:
import java.util.regex. * public class CharacterExample {public static void main (String args []) {// falso (no x, yoz) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // verdadero (entre xo yoz) System.out.println (Pattern.matches ('[xyz]', 'x')) // falso (xey vienen más de una vez) System .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}Cuantificadores de expresiones regulares
Los cuantificadores especifican el número de apariciones de un carácter. La siguiente tabla representa varios cuantificadores.
| Regex | Descripción |
|---|---|
| X? | X ocurre una vez o nunca |
| X+ | X ocurre una o más veces |
| X* | X ocurre cero o más veces |
| X {n} | X ocurre solo n veces |
| X {n,} | X ocurre no más veces |
| X{y,z} | X ocurre al menos y veces pero menos de z veces |
Ejemplo:
import java.util.regex. * public class Ejemplo {public static void main (String args []) {System.out.println ('? quantifier ....') // (aoy oz viene una vez) System.out.println (Pattern.matches ('[ayz]?', 'A')) // resultado: verdadero System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay yz vienen más de una vez) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // salida: falso // (a viene más de una vez) System. out.println (Pattern.matches ('[ayz]?', 'amnta')) // resultado: falso // (a o yoz deben aparecer una vez) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // salida: falso System.out.println (' + cuantificador .... ') // (ao yoz una o más veces) System.out.println (Patrón .matches ('[ayz] +', 'a')) // salida: verdadero // (a viene más de una vez) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a o yoz viene más de una vez) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // output: true // (z yt no coinciden con el patrón) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // resultado: falso System.out.println ('* cuantificador ....') // (aoy oz pueden aparecer cero o más veces ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // resultado: verdadero}}Básicamente, buscará el cuantificador coincidente y coincidirá con el resultado de la búsqueda.
Metacaracteres Regex
Los metacaracteres de expresión regular funcionan como códigos cortos. Echemos un vistazo a la siguiente tabla para comprender los distintos tipos de metacaracteres.
| Regex | Descripción |
|---|---|
| . | Puede ser cualquier carácter (puede o no coincidir con el terminador) |
| re | Representa cualquier dígito, menos [0-9] |
| re | Representa cualquier no dígito, abreviatura de [^ 0-9] |
| s | Representa cualquier carácter de espacio en blanco, abreviatura de [tnx0Bfr] |
| S | Puede ser un carácter que no sea un espacio en blanco, abreviatura de [^ s] |
| en | Puede ser un carácter de palabra, abreviatura de [a-zA-Z_0-9] |
| EN | Representa cualquier carácter que no sea una palabra, abreviatura de [^ w] |
| b | Representa el límite de una palabra |
| B | Es un límite sin palabras |
Ejemplo:
import java.util.regex. * public class MetacharExample {public static void main (String args []) {// d significa dígitos System.out.println ('metacaracteres d ....') // (sin dígitos) System.out.println (Pattern.matches ('d', 'abc')) // Salida: falso // (dígito y viene una vez) System.out.println (Pattern.matches ('d', '1') ) // Salida: verdadero // (dígito pero viene más de una vez) System.out.println (Pattern.matches ('d', '4443')) // Salida: falso // (dígito y carácter) System.out .println (Pattern.matches ('d', '323abc')) // Salida: falso // D significa System.out.println sin dígitos ('metacaracteres D ....') // (sin dígitos pero viene más de una vez) System.out.println (Pattern.matches ('D', 'abc')) // Salida: falso // Es un dígito System.out.println (Pattern.matches ('D', '1 ')) // Salida: falso System.out.println (Pattern.matches (' D ',' 4443 ')) // Salida: falso // (dígitos y caracteres) System.out.println (Pattern.matches (' D ',' 323abc ')) // Salida: falso // (sin dígitos y viene una vez) System.out.println (Pattern.matches (' D ',' m ')) // Salida: verdadero System.out .pr intln ('metacaracteres D con cuantificador ....') // (sin dígitos y puede venir 0 o más veces) System.out.println (Pattern.matches ('D *', 'abc')) // Salida : cierto } }Según las condiciones mencionadas anteriormente, mostrará la salida. Asi es como funciona. Entonces, eso fue todo sobre varios tipos de Regex. Con esto llegamos al final de este artículo. yoEspero que le haya resultado informativo. Si desea obtener más información, puede consultar nuestro también.
Revisar la por Edureka, una empresa de aprendizaje en línea de confianza con una red de más de 250.000 alumnos satisfechos repartidos por todo el mundo. Estamos aquí para ayudarlo en cada paso de su viaje, para que, además de estas preguntas de la entrevista de Java, se desarrolle un plan de estudios diseñado para estudiantes y profesionales que desean ser Desarrolladores de Java.
Tienes una pregunta para nosotros? Por favor, menciónelo en la sección de comentarios de este artículo de 'Java Regex' y nos comunicaremos con usted lo antes posible.