Java Academy · Lección

Reemplazo con expresiones regulares

replaceAll y referencias inversas

Reemplazo con expresiones regulares es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Reemplazar con expresiones regulares

Las expresiones regulares no sirven solo para buscar; también pueden transformar texto. replaceAll sustituye cada coincidencia por una cadena de reemplazo.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("a1b22c333");
        System.out.println(m.replaceAll("#"));
    }
}

Atajo String.replaceAll

String.replaceAll(regex, replacement) es una expresión concisa y práctica que compila el patrón internamente.

public class Main {
    public static void main(String[] args) {
        String cleaned = "hello   world  again".replaceAll("\\s+", " ");
        System.out.println(cleaned);
    }
}

replaceFirst

replaceFirst sustituye solo la primera coincidencia y deja intactas las posteriores.

public class Main {
    public static void main(String[] args) {
        String s = "cat cat cat".replaceFirst("cat", "dog");
        System.out.println(s);
    }
}

Referencias a grupos en los reemplazos

En la cadena de reemplazo, $1, $2, etc. insertan el texto capturado por esos grupos. Esto permite reordenar o reformatear el contenido coincidente.

public class Main {
    public static void main(String[] args) {
        String iso = "30/05/2026".replaceAll("(\\d{2})/(\\d{2})/(\\d{4})", "$3-$2-$1");
        System.out.println(iso);
    }
}

Referencias a grupos con nombre

También puede hacer referencia a grupos con nombre en el reemplazo mediante ${name}.

public class Main {
    public static void main(String[] args) {
        String r = "alice@example.com"
            .replaceAll("(?<user>\\w+)@(?<host>[\\w.]+)", "${user} at ${host}");
        System.out.println(r);
    }
}

Escapar el dólar y la barra invertida

Como $ y \ son caracteres especiales en los reemplazos, escape un dólar literal como \$. Matcher.quoteReplacement los escapa por usted.

import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        String price = "100".replaceAll("\\d+", Matcher.quoteReplacement("$100"));
        System.out.println(price);
    }
}

Reemplazos calculados con la función de replaceAll

Desde Java 9, Matcher.replaceAll puede recibir una función, lo que permite calcular cada reemplazo a partir de la coincidencia.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("a1 b2 c3");
        String out = m.replaceAll(mr -> String.valueOf(Integer.parseInt(mr.group()) * 10));
        System.out.println(out);
    }
}

Convertir a mayúsculas las palabras coincidentes

La variante que recibe una función resulta especialmente útil cuando el reemplazo depende del texto coincidente, por ejemplo, para convertir cada palabra a mayúsculas.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\b\\w").matcher("hello there world");
        String title = m.replaceAll(mr -> mr.group().toUpperCase());
        System.out.println(title);
    }
}

appendReplacement y appendTail

Para tener un control total, use un bucle con find y construya la salida mediante appendReplacement y después appendTail. Esta es la técnica clásica de bajo nivel.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("a1b2");
        StringBuilder sb = new StringBuilder();
        while (m.find()) {
            m.appendReplacement(sb, "[" + m.group() + "]");
        }
        m.appendTail(sb);
        System.out.println(sb);
    }
}

Referencias inversas en el patrón

Las referencias inversas del patrón (\1) coinciden con texto repetido y resultan útiles para eliminar palabras duplicadas durante el reemplazo.

public class Main {
    public static void main(String[] args) {
        String fixed = "the the end end".replaceAll("\\b(\\w+) \\1\\b", "$1");
        System.out.println(fixed);
    }
}

Eliminar caracteres no deseados

Un uso frecuente consiste en limpiar la entrada sustituyendo por una cadena vacía todo lo que esté fuera de un conjunto permitido.

public class Main {
    public static void main(String[] args) {
        String digits = "(555) 123-4567".replaceAll("[^0-9]", "");
        System.out.println(digits);
    }
}

Comprobación rápida

En una cadena de reemplazo para replaceAll, ¿qué significa $2?

Recapitulación

Ha transformado texto con expresiones regulares:

replaceAll y replaceFirst sustituyen coincidencias; String ofrece atajos.
$1 / ${name} insertan grupos capturados en los reemplazos; escape el $ literal como \$ o mediante quoteReplacement.
La variante de replaceAll que recibe una función calcula los reemplazos a partir de cada coincidencia.
appendReplacement + appendTail proporcionan control manual total.

Preguntas frecuentes

¿La lección «Reemplazo con expresiones regulares» es gratis?

Sí — el texto completo de «Reemplazo con expresiones regulares» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Reemplazo con expresiones regulares»?

replaceAll y referencias inversas Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Reemplazo con expresiones regulares»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy