En el mundo de la programación Java, las expresiones regulares (regex) proporcionan herramientas poderosas para el filtrado de caracteres y la manipulación de texto. Este tutorial explora técnicas completas para filtrar y procesar caracteres utilizando las capacidades de regex de Java, ayudando a los desarrolladores a mejorar sus habilidades de manejo de cadenas y a crear soluciones de procesamiento de texto más robustas.
Las expresiones regulares (regex) en Java son herramientas poderosas para la coincidencia de patrones y la manipulación de texto. Proporcionan una forma concisa y flexible de buscar, validar y modificar cadenas basadas en patrones específicos.
Los patrones de expresiones regulares (regex) son secuencias de caracteres que definen un patrón de búsqueda. Pueden incluir:
| Método | Descripción | Ejemplo |
|---|---|---|
| matches() | Comprueba si la cadena completa coincide con el patrón | "123".matches("\\d+") |
| find() | Busca un patrón dentro de la cadena | Pattern.compile("\\w+").matcher(text).find() |
| replaceAll() | Reemplaza todas las coincidencias con el texto especificado | text.replaceAll("\\s", "_") |
. Coincide con cualquier carácter individual* Coincide con cero o más ocurrencias+ Coincide con una o más ocurrencias? Coincide con cero o una ocurrencia^ Coincide con el inicio de la cadena$ Coincide con el final de la cadenaLas expresiones regulares (regex) son esenciales para:
En LabEx, recomendamos dominar las expresiones regulares (regex) como una habilidad fundamental para los desarrolladores de Java.
String text = "Hello, Java Regex!";
boolean isMatch = text.matches(".*Regex.*");
System.out.println(isMatch); // trueEste ejemplo demuestra una técnica básica de coincidencia de patrones de expresiones regulares (regex) en Java.
El filtrado de caracteres es una técnica crucial en el procesamiento de texto que permite a los desarrolladores eliminar, reemplazar o extraer selectivamente caracteres específicos de las cadenas utilizando expresiones regulares.
| Método | Propósito | Ejemplo |
|---|---|---|
| replaceAll() | Eliminar caracteres específicos | text.replaceAll("[^a-zA-Z]", "") |
| replaceFirst() | Reemplazar la primera ocurrencia | text.replaceFirst("\\d", "X") |
| matches() | Validar el conjunto de caracteres | text.matches("[A-Za-z]+") |
public class CharacterFilter {
public static String filterAlphanumeric(String input) {
return input.replaceAll("[^a-zA-Z0-9]", "");
}
public static void main(String[] args) {
String text = "Hello, World! 123";
String filtered = filterAlphanumeric(text);
System.out.println(filtered); // Output: HelloWorld123
}
}public class CharacterExtractor {
public static String extractDigits(String input) {
return input.replaceAll("[^0-9]", "");
}
public static void main(String[] args) {
String text = "LabEx2023 Course";
String digits = extractDigits(text);
System.out.println(digits); // Output: 2023
}
}\d Coincide con dígitos\w Coincide con caracteres de palabra\s Coincide con espacios en blanco\p{Punct} Coincide con caracteres de puntuaciónEn LabEx, enfatizamos la importancia de dominar las técnicas de filtrado de caracteres para una manipulación eficiente de cadenas en Java.
public class EmailValidator {
private static final String EMAIL_REGEX =
"^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
public static boolean isValidEmail(String email) {
return email.matches(EMAIL_REGEX);
}
public static void main(String[] args) {
System.out.println(isValidEmail("user@labex.io")); // true
System.out.println(isValidEmail("invalid-email")); // false
}
}public class PasswordValidator {
private static final String PASSWORD_REGEX =
"^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,20}$";
public static boolean isStrongPassword(String password) {
return password.matches(PASSWORD_REGEX);
}
public static void main(String[] args) {
System.out.println(isStrongPassword("LabEx2023!")); // true
System.out.println(isStrongPassword("weak")); // false
}
}| Patrón | Descripción | Ejemplo |
|---|---|---|
\d{3}-\d{2}-\d{4} |
Número de Seguro Social | 123-45-6789 |
^\+?1?\d{10,14}$ |
Número de teléfono | +1234567890 |
\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b |
Validación de correo electrónico | user@example.com |
public class DataExtractor {
public static void extractInfo(String text) {
// Extract dates
Pattern datePattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
Matcher dateMatcher = datePattern.matcher(text);
while (dateMatcher.find()) {
System.out.println("Found date: " + dateMatcher.group());
}
}
public static void main(String[] args) {
String sampleText = "LabEx course started on 2023-07-15";
extractInfo(sampleText);
}
}public class TextTokenizer {
public static void tokenizeText(String text) {
// Split by multiple delimiters
String[] tokens = text.split("[,;\\s]+");
for (String token : tokens) {
System.out.println("Token: " + token);
}
}
public static void main(String[] args) {
String input = "Java, Regex; Parsing, Techniques";
tokenizeText(input);
}
}Al dominar las técnicas de filtrado de caracteres de expresiones regulares (regex) en Java, los desarrolladores pueden validar, extraer y transformar datos de texto de manera eficiente y precisa. Estos métodos ofrecen enfoques flexibles y concisos para manejar tareas complejas de procesamiento de cadenas, lo que permite escribir código más elegante y con mejor rendimiento en diversas aplicaciones Java.
