CEPC

Manejo básico de caracteres con expresiones Regulares

Supongamos que se nos pide realizar un programa que lea una cadena introducida por el teclado del usuario y este muestre:

• Cantidad de vocales y consonantes
• Cantidad de letras en minúsculas y mayúsculas.

Para la creación de los métodos antes mencionados se van a utilizar expresiones regulares sencillas.

¿ Qué es una expresión regular ?
    Es una secuencia de caracteres que forma un patrón de búsqueda

El patrón a utilizar en este ejemplo es sencillo, saber si es un carácter esta entre la A mayúscula y la Z mayúscula, al igual que a y z minúscula. También contando el carácter Ññ.

La expresión regular para las mayúsculas es la siguiente:

        String mayusculas = "[A-Z]|[Ñ]";

Para las minúsculas es:

        String minusculas = "[a-z]|[ñ]";

Para saber si el caracter es una vocal:

        String vocales = "[aeiouAEIOU]";

Y para saber si es una vocal con acento es:

        String acentos = "[áéíóúÁÉÍÓÚ]";

Con lo antes mencionado se crea un método para el punto número uno.

1.- Cantidad de Vocales y Consonantes.

Se extrae de la cadena introducida por teclado del usuario carácter por carácter y se comprueba que sea una letra del abecedario.

Teniendo en cuenta esto, se creara un ciclo donde una variable i comenzara en 0 y llegara hasta el tamaño de la cadena -1 , incrementando en cada iteración la i en +1. Nos quedaría una estructura así :

     for (int i = 0 ; i < cadenaLeida.length() ; i++) {

        // lógica del problema....

    }

Las expresiones regulares solo funcionan en objetos String por lo tanto convertimos el carácter leído en String. El cual se hace de esta manera:

    String letra = cadenaLeida.charAt(i)+"";

Al agregarle un + [mas] y unas comillas, el carácter actual se convierte en String listo para aplicar las expresiones regulares correspondientes.

Se compara la letra con las expresiones regulares:

   if(letra.matches(mayusculas) || letra.matches(minusculas)|| letra.matches(acentos)){
       // Soy una letra del abecedario.
   }

Si el carácter es una letra del abecedario se pregunta si es vocal con o sin acento.

   if (letra.matches(vocales) || letra.matches(acentos)){

         contadorVocales++;

   }  else  {

         contadorConsonantes++;

   }

Solo resta mandar a imprimir el resultado de los contadores. El método completo quedaría de la siguiente manera:

    public static void contarVocales_Consonantes(String cadenaLeida) {
        int contadorVocales = 0 ;
        int contadorConsonantes = 0;
        
        String acentos = "[áéíóúÁÉÍÓÚ]";
        String mayusculas = "[A-Z]|[Ñ]";
        String minusculas = "[a-z]|[ñ]";
        String vocales = "[aeiouAEIOU]";
        
        for (int i = 0 ; i< cadenaLeida.length() ; i++){
            String letra = cadenaLeida.charAt(i)+"";
            
            if(letra.matches(mayusculas) || letra.matches(minusculas)|| letra.matches(acentos)){
                if(letra.matches(vocales) || letra.matches(acentos)){
                    contadorVocales++;
                }else{
                    contadorConsonantes++;
                }
            }
        }
        System.out.println("El número de Vocales : "+contadorVocales);
        System.out.println("El número de Consontantes : "+contadorConsonantes);
    }

2.- Cantidad de letras en minúsculas y mayúsculas.

Llegamos al método de contar la cantidad de mayúsculas y minúsculas. Re-utilizando el código del punto anterior, se concluye que se debe quitar lineas al código. Las lineas a remover son las preguntas si son vocales o consonantes.

Y ahora el if se modifica, preguntando solamente por los debidos intervalos, de mayúsculas y minúscula y respectivamente pasa lo mismo con los caracteres especiales.

Modificando el nombre de las variables utilizadas anteriormente los contadores se inician desde 0.

        int contadorMayusculas = 0;
        int contadorMinusculas = 0;


Y se recorre la palabra extrayendo las letras e incrementando los contadores en sus respectivos bandos.
Sin olvidar las letras con acentos, que en este caso solo serían las vocales. Las expresiones regulares son:

        String acentosMinusculas = "[áéíóú]";
        String acentosMayusculas = "[ÁÉÍÓÚ]";

 if (letra.matches("[A-Z]") || letra.equals("Ñ") || letra.matches(acentosMayusculas)) {
        contadorMayusculas++;
   } else if (letra.matches("[a-z]") || letra.equals("ñ") || letra.matches(acentosMinusculas)) {
        contadorMinusculas++;
   }

El método quedaría de la siguiente manera :

    public static void cantidadLetras_Mayusculas_Minusculas(String cadenaLeida) {
        int contadorMayusculas = 0 ;
        int contadorMinusculas = 0;
        
        String acentosMinusculas = "[áéíóú]";
        String acentosMayusculas = "[ÁÉÍÓÚ]";

        for (int i = 0 ; i< cadenaLeida.length() ; i++){
            String letra = cadenaLeida.charAt(i)+"";
            
            if(letra.matches("[A-Z]") || letra.equals("Ñ") || letra.matches(acentosMayusculas)) {){
                contadorMayusculas++;
            } else if(letra.matches("[a-z]") || letra.equals("ñ")|| letra.matches(acentosMinusculas)) {
                contadorMinusculas++;
            }
        }
        System.out.println("Número de Mayúsculas : "+contadorMayusculas);
        System.out.println("Número de Minúsculas : "+contadorMinusculas);
    }

De esta manera se resuelve el ejercicio, que el objetivo es parecido al anterior. Utilizando diferente método.

El código completo es :

import java.util.Scanner;

/*
 Supongamos que se nos pide realizar un programa que lea una cadena introducida por el teclado del usuario y este muestre:

 - Cantidad de vocales y consonantes
 - Cantidad de letras en minúsculas y mayúsculas.

 */

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner (System.in,"ISO-8859-1");
        
        String cadenaLeida = s.nextLine();
        
        contarVocales_Consonantes(cadenaLeida);
        cantidadLetras_Mayusculas_Minusculas(cadenaLeida);
    }

    public static void contarVocales_Consonantes(String cadenaLeida) {
        int contadorVocales = 0 ;
        int contadorConsonantes = 0;
        
        String acentos = "[áéíóúÁÉÍÓÚ]";
        String mayusculas = "[A-Z]|[Ñ]";
        String minusculas = "[a-z]|[ñ]";
        String vocales = "[aeiouAEIOU]";
        
        for (int i = 0 ; i< cadenaLeida.length() ; i++){
            String letra = cadenaLeida.charAt(i)+"";
            
            if(letra.matches(mayusculas) || letra.matches(minusculas)|| letra.matches(acentos)){
                if(letra.matches(vocales) || letra.matches(acentos)){
                    contadorVocales++;
                }else{
                    contadorConsonantes++;
                }
            }
        }
        System.out.println("El número de Vocales : "+contadorVocales);
        System.out.println("El número de Consontantes : "+contadorConsonantes);
    }

    public static void cantidadLetras_Mayusculas_Minusculas(String cadenaLeida) {
        int contadorMayusculas = 0 ;
        int contadorMinusculas = 0;
        
        String acentosMinusculas = "[áéíóú]";
        String acentosMayusculas = "[ÁÉÍÓÚ]";

        for (int i = 0 ; i< cadenaLeida.length() ; i++){
            String letra = cadenaLeida.charAt(i)+"";
            
            if(letra.matches("[A-Z]") || letra.equals("Ñ") || letra.matches(acentosMayusculas)) {){
                contadorMayusculas++;
            } else if(letra.matches("[a-z]") || letra.equals("ñ")|| letra.matches(acentosMinusculas)) {
                contadorMinusculas++;
            }
        }
        System.out.println("Número de Mayúsculas : "+contadorMayusculas);
        System.out.println("Número de Minúsculas : "+contadorMinusculas);
    }
}

Otra manera de resolver este ejercicio y para facilitar al programador muchas cosas, es crear un axuliar  de la cadena leída y convertirla  por puras mayúsculas o minúsculas según decida el programador. Y solo se preguntaría por los caracteres elegidos. Facilitando y comprimiendo el código.