Cómo verificar si una cadena está en minúsculas en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena de texto está en minúsculas en Java. Exploraremos diferentes métodos para lograr esto, comenzando por comparar cadenas ignorando mayúsculas y minúsculas utilizando toLowerCase() e equalsIgnoreCase().

Luego aprenderás cómo iterar a través de una cadena y usar Character.isLowerCase() para verificar cada carácter individualmente. Finalmente, cubriremos cómo manejar caracteres que no son letras al realizar esta comprobación.

Comparar cadenas con toLowerCase()

En este paso, aprenderemos cómo comparar cadenas en Java ignorando las mayúsculas y minúsculas de las letras. Esta es una tarea común cuando se desea comprobar si dos cadenas son iguales, independientemente de si utilizan letras mayúsculas o minúsculas.

Vamos a crear un nuevo archivo Java para practicar esto.

Abre el WebIDE si no está abierto.
En el Explorador de archivos a la izquierda, asegúrate de estar en el directorio ~/project.
Haz clic derecho en el espacio vacío del Explorador de archivos, selecciona "Nuevo archivo" y llámalo CaseInsensitiveCompare.java.
Abre el archivo CaseInsensitiveCompare.java en el editor.

Copia y pega el siguiente código en el editor:

public class CaseInsensitiveCompare {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        String str3 = "World";

        // Comparing strings directly (case-sensitive)
        boolean areEqualCaseSensitive = str1.equals(str2);
        System.out.println("Case-sensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseSensitive);

        // Comparing strings ignoring case
        boolean areEqualCaseInsensitive = str1.equalsIgnoreCase(str2);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseInsensitive);

        // Comparing str1 and str3 ignoring case
        boolean areEqualStr1Str3 = str1.equalsIgnoreCase(str3);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str3 + "\": " + areEqualStr1Str3);
    }
}

En este código:

Declaramos tres variables de tipo String: str1, str2 y str3.
str1.equals(str2) realiza una comparación sensible a mayúsculas y minúsculas. Devolverá false porque "Hello" y "hello" son diferentes debido a la 'H' mayúscula.
str1.equalsIgnoreCase(str2) realiza una comparación insensible a mayúsculas y minúsculas. Devolverá true porque "Hello" y "hello" son iguales cuando se ignora la capitalización.
También comparamos str1 y str3 ignorando la capitalización para mostrar que palabras diferentes siguen siendo consideradas diferentes.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project.
Compila el programa Java utilizando el comando javac:
```
javac CaseInsensitiveCompare.java
```
Si no hay errores, no verás salida. Se creará un archivo CaseInsensitiveCompare.class en el directorio ~/project.
Ejecuta el programa Java compilado utilizando el comando java:
```
java CaseInsensitiveCompare
```
Deberías ver la siguiente salida:
```
Case-sensitive comparison of "Hello" and "hello": false
Case-insensitive comparison of "Hello" and "hello": true
Case-insensitive comparison of "Hello" and "World": false
```
Esta salida confirma que equals() es sensible a mayúsculas y minúsculas, mientras que equalsIgnoreCase() las ignora.

Utilizar equalsIgnoreCase() es una forma conveniente de comparar cadenas sin preocuparse por si las letras son mayúsculas o minúsculas.

Usar Character.isLowerCase() en un bucle

En el paso anterior, aprendimos cómo comparar cadenas enteras ignorando las mayúsculas y minúsculas. A veces, es posible que necesites examinar caracteres individuales dentro de una cadena y verificar si son minúsculas o mayúsculas. Java proporciona métodos útiles para esto en la clase Character.

En este paso, usaremos el método Character.isLowerCase() dentro de un bucle para contar el número de letras minúsculas en una cadena.

Abre el WebIDE si no está abierto.
En el Explorador de archivos a la izquierda, asegúrate de estar en el directorio ~/project.
Crea un nuevo archivo llamado CountLowercase.java en el directorio ~/project.
Abre el archivo CountLowercase.java en el editor.
Copia y pega el siguiente código en el editor:
```
public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;

        // Loop through each character in the string
        for (int i = 0; i < text.length(); i++) {
            char character = text.charAt(i); // Get the character at the current index

            // Check if the character is a lowercase letter
            if (Character.isLowerCase(character)) {
                lowercaseCount++; // Increment the counter if it's lowercase
            }
        }

        System.out.println("The string is: \"" + text + "\"");
        System.out.println("Number of lowercase letters: " + lowercaseCount);
    }
}
```
Analicemos este código:
- Tenemos una variable String llamada text que contiene una mezcla de letras mayúsculas, letras minúsculas, números y símbolos.
- Inicializamos una variable entera lowercaseCount en 0. Esta variable almacenará el recuento de letras minúsculas.
- Usamos un bucle for para iterar a través de cada carácter de la cadena. El bucle se ejecuta desde el índice 0 hasta (pero sin incluir) la longitud de la cadena.
- text.charAt(i) obtiene el carácter en el índice actual i.
- Character.isLowerCase(character) es un método que devuelve true si el character dado es una letra minúscula, y false en caso contrario.
- Si Character.isLowerCase() devuelve true, incrementamos lowercaseCount.
- Finalmente, imprimimos la cadena original y el recuento total de letras minúsculas.
Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project.
Compila el programa Java:
```
javac CountLowercase.java
```
Si la compilación es exitosa, se creará un archivo CountLowercase.class.
Ejecuta el programa Java compilado:
```
java CountLowercase
```
Deberías ver la siguiente salida:
```
The string is: "Hello World 123!"
Number of lowercase letters: 8
```
La salida muestra que hay 8 letras minúsculas en la cadena "Hello World 123!" ('e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd').

Usar Character.isLowerCase() dentro de un bucle te permite realizar un análisis carácter por carácter de una cadena, lo cual es útil para diversas tareas de procesamiento de texto.

Ignorar caracteres que no son letras

En el paso anterior, contamos las letras minúsculas. Sin embargo, las cadenas pueden contener diversos caracteres como números, espacios y símbolos. Cuando se comparan cadenas o se analiza su contenido, a menudo se desea ignorar estos caracteres no alfabéticos.

En este paso, modificaremos nuestro programa para procesar solo caracteres alfabéticos e ignorar todo lo demás. Utilizaremos el método Character.isLetter() para esto.

Abre el WebIDE si no está abierto.
Abre el archivo CountLowercase.java que creaste en el paso anterior.

Modifica el código para incluir una comprobación de si un carácter es una letra antes de comprobar si es minúscula. Reemplaza el código existente con lo siguiente:

public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;
        StringBuilder lettersOnly = new StringBuilder(); // To store only letter characters

        // Loop through each character in the string
        for (int i = 0; i < text.length(); i++) {
            char character = text.charAt(i); // Get the character at the current index

            // Check if the character is a letter
            if (Character.isLetter(character)) {
                lettersOnly.append(character); // Add the letter to our new string

                // Check if the letter is lowercase
                if (Character.isLowerCase(character)) {
                    lowercaseCount++; // Increment the counter if it's lowercase
                }
            }
        }

        System.out.println("The original string is: \"" + text + "\"");
        System.out.println("Letters only string: \"" + lettersOnly.toString() + "\"");
        System.out.println("Number of lowercase letters (ignoring non-letters): " + lowercaseCount);
    }
}

Esto es lo que hemos agregado y cambiado:

Introdujimos un StringBuilder llamado lettersOnly. StringBuilder se utiliza para construir cadenas de manera eficiente, especialmente cuando se agregan caracteres en un bucle.
Dentro del bucle, agregamos una condición if (Character.isLetter(character)). Esto comprueba si el character actual es una letra (ya sea mayúscula o minúscula).
Si el carácter es una letra, lo agregamos al StringBuilder lettersOnly utilizando lettersOnly.append(character).
La comprobación Character.isLowerCase(character) ahora está anidada dentro de la comprobación Character.isLetter(), lo que asegura que solo contamos las letras minúsculas entre los caracteres que realmente son letras.
Finalmente, imprimimos la cadena original, la cadena que contiene solo letras y el recuento de letras minúsculas entre esas letras.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project.
Compila el programa Java modificado:
```
javac CountLowercase.java
```
Asegúrate de que no haya errores de compilación.
Ejecuta el programa Java compilado:
```
java CountLowercase
```
Deberías ver la siguiente salida:
```
The original string is: "Hello World 123!"
Letters only string: "HelloWorld"
Number of lowercase letters (ignoring non-letters): 8
```
Observa que la "cadena solo con letras" ahora contiene solo "HelloWorld", y el recuento de letras minúsculas sigue siendo 8, ya que solo estamos contando las letras minúsculas entre las letras reales.

Usar Character.isLetter() es muy útil cuando necesitas filtrar los caracteres no alfabéticos de una cadena antes de procesarla más.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si una cadena está en minúsculas en Java. Exploramos dos métodos principales. En primer lugar, comparamos cadenas utilizando equalsIgnoreCase() para realizar comparaciones sin distinción entre mayúsculas y minúsculas, demostrando cómo comprobar si dos cadenas son iguales independientemente de las mayúsculas y minúsculas de las letras.

En segundo lugar, aunque no se proporcionaron todos los detalles, los pasos indican que aprenderíamos a iterar a través de una cadena utilizando un bucle y a utilizar Character.isLowerCase() para verificar si los caracteres individuales son minúsculas, y también a considerar cómo ignorar los caracteres no alfabéticos durante este proceso.