En PC Resumen vamos a hablar del Reemplazo de subcadenas y división de cadenas en Java. A veces es conveniente reemplazar partes de una cadena, o dividir una cadena en diferentes trozos. Para hacer esto, la clase String proporciona los métodos replaceAll, replaceFirst y split. Estos métodos se muestran en el siguiente código:

public class SubstitucionRegex {

    public static void main(String args[]) {
        String primeraCadena = "Este enunciado termina con 5 estrellas *****";
        String segundaCadena = "1, 2, 3, 4, 5, 6, 7, 8";
        System.out.printf("Cadena 1 original: %s\n", primeraCadena);
        // substituye '*' por '^'
        primeraCadena = primeraCadena.replaceAll("\\*", "^");
        System.out.printf("^ substituye a *: %s\n", primeraCadena);
        // substituye 'estrellas' por 'intercaladores'
        primeraCadena = primeraCadena.replaceAll( "estrellas", "intercaladores" );
        System.out.printf("\"intercaladores\" substituye a \"estrellas\": %s\n", primeraCadena);
        // substituye las palabras con 'palabra'
        System.out.printf("Cada palabra se substituye por \"palabra\": %s\n\n", primeraCadena.replaceAll("\\w+", "palabra"));
        System.out.printf("Cadena 2 original: %s\n", segundaCadena ); 
        // substituye los tres primeros dígitos por 'digito'
        for (int i = 0; i < 3; i++) {
            segundaCadena = segundaCadena.replaceFirst( "\\d", "digit" );
        }
        System.out.printf("Los tres primeros dígitos se han substituido por \"digito\" : %s\n", segonaCadena);
        String salida = "Cadena dividida en comas: [";
        String[] resultados = segundaCadena.split( ",\\s*" ); // se divide a las comas
        for (String cadena : resultados) {
            salida += "\"" + cadena + "\", ";
        }
        // elimina la coma adicional i añade un claudátor
        salida = salida.substring(0, salida.length() - 2 ) + "]";
        System.out.println(salida);
    }
} 

En PC Resumen vamos a explicar las expresiones regulares conocidas como cuantificadores en el lenguaje de programación Java. El asterisco y el signo más se conocen como cuantificadores. En la tabla siguiente se ven todos los cuantificadores.

Cuantificador Concuerda con
* Cero o más ocurrencias
+ Una o más ocurrencias
? Cero o una ocurrencia
{n} Exactamente con n ocurrencias
{n,} Al menos con "n" ocurrencias
{n,m} Entre "n" y "m" (inclusivo) ocurrencias

 

Todos los cuantificadores afectan sólo a la subexpresión que inmediatamente antes del cuantificador.

Los cuantificadores pueden aplicarse a patrones cerrados entre paréntesis para crear expresiones regulares más complejas.

Todos los cuantificadores son tacaños. Esto significa que concordarán con todas las ocurrencias que puedan siempre y cuando haya concordancia. No obstante si alguno de estos cuantificadores va seguido por un signo de interrogación, el cuantificador se vuelve perezoso. De esta forma concuerda con la menor cantidad de ocurrencias siempre y cuando haya concordancia.

El método matches verifica si una cadena completa se conforma a una expresión regular. Si sólo una subcadena concuerda con la expresión regular, el método devuelve false.

En PC Resumen hablaremos de como funcionan las expresiones regulares en Java. Las expresiones regulares son secuencias de caracteres y símbolos que definen un conjunto de cadenas. Son útiles para validar la entrada y asegurar que los datos estén en un formato específico. Una aplicación de las expresiones regulares es facilitar la construcción de un compilador. A menudo se utiliza una expresión regular larga y compleja para validar sintaxis de un programa. Si el código del programa no coincide con la expresión regular, el compilador sabe que hay un error de sintaxis en el código.

La clase String proporciona diferentes métodos para realizar operaciones con expresiones regulares, siendo la más simple la operación de concordancia. El método matches recibe una cadena que especifica la expresión regular, igualando el contenido del objeto String que llama al método con la expresión regular. Este método devuelve un booleano indicando si ha habido concordancia o no.

Una expresión regular está formada por caracteres literales y símbolos especiales. la tabla siguiente especifica algunas clases predefinidas de caracteres que pueden utilizarse con las expresiones regulares. Una clase de carácter es una secuencia de escape que representa a un grupo de caracteres. Un dígito es cualquier carácter numérico. Un carácter de palabra es cualquier letra, cualquier dígito o el carácter de guión bajo. Un carácter de espacio en blanco, es un espacio, tabulador, retorno de carro nueva línea o avance de página. cada clase de carácter iguala con un solo carácter en la cadena que intentamos hacer concordar con la expresión regular.

En PC Resumen vamos a hablar de la Clase StringTokenizer en el lenguaje de programación en Java. Cuando nosotros leemos una frase, nuestra mente la divide en tokens (palabras individuales y signos de puntuación, cada uno de los cuales nos da un significado). Los compiladores también llevan a cabo la descomposición de instrucciones en piezas individuales tales como palabras clave, identificadores, operadores, etc.

En PC Resumen vamos a hablar de la Clase Character en el lenguaje de programación Java. La mayoría de los métodos de esta clase son estáticos, diseñados para facilitar el procesamiento de valores char individuales. Esta clase también tiene un constructor que recibe un argumento char para inicializar un objeto Character.

En el siguiente programa se ven muchos de estos métodos, para más información, consultar la documentación de la API de Java.

import java.util.Scanner;

public class MetodesStaticChar {

    public static void main (String args[]) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Escribe un carácter y pulsa Intro");
        String entrada = scanner.next();
        char c = entrada.charAt(0);
        System.out.printf("Está definido: %b\n", Character.isDefined(c));
        System.out.printf("Es dígito: %b\n", Character.isDigit(c));
        System.out.printf("Es el primer carácter en un identificador de Java: %b\n", Character.isJavaIdentifierStart(c));
        System.out.printf("Es parte de un identificador de Java: %b\n", Character.isJavaIdentifierPart(c));
        System.out.printf("Es letra: %b\n", Character.isLetter(c));
        System.out.printf("Es letra o dígito: %b\n", Character.isLetterOrDigit(c));
        System.out.printf("Es minúscula: %b\n", Character.isLowerCase(c));
        System.out.printf("Es mayúscula: %b\n", Character.isUpperCase(c));
        System.out.printf("A mayúscula: %s\n", Character.toUpperCase(c));
        System.out.printf("A minúscula: %s\n", Character.toLowerCase(c));
    }
}