LabEx
EntrarÚnete

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

JavaBeginner
Practicar Ahora

Introducción

En este laboratorio (lab), aprenderás cómo verificar si una cadena (string) está en mayúsculas en Java. Exploraremos diferentes métodos para lograr esto, comenzando por comparar la cadena original con su versión en mayúsculas utilizando toUpperCase().

A continuación, aprenderás cómo iterar a través de una cadena y utilizar el método Character.isUpperCase() para verificar la capitalización de caracteres individuales. Finalmente, abordaremos cómo manejar los caracteres que no son letras dentro de la cadena al realizar estas comprobaciones.

Comparar una cadena (string) con toUpperCase()

En este paso, aprenderemos cómo comparar cadenas en Java, centrándonos específicamente en cómo realizar comparaciones sin distinción entre mayúsculas y minúsculas. Esta es una tarea común en la programación, por ejemplo, cuando se verifica si un usuario ingresó "yes", "Yes" o "YES".

Primero, creemos un nuevo archivo Java llamado StringCompare.java en tu directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda y seleccionando "Nuevo archivo", luego escribiendo StringCompare.java.

Ahora, abre el archivo StringCompare.java en el editor y agrega el siguiente código:

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

        // Case-sensitive comparison
        boolean areEqualCaseSensitive = str1.equals(str2);
        System.out.println("Case-sensitive comparison: " + areEqualCaseSensitive);

        // Case-insensitive comparison using toUpperCase()
        boolean areEqualCaseInsensitive = str1.toUpperCase().equals(str2.toUpperCase());
        System.out.println("Case-insensitive comparison using toUpperCase(): " + areEqualCaseInsensitive);
    }
}

Desglosemos este código:

  • Declaramos dos variables de tipo String, str1 y str2, con diferentes mayúsculas y minúsculas.
  • str1.equals(str2) realiza una comparación que distingue entre mayúsculas y minúsculas. Devolverá true solo si las cadenas son exactamente iguales, incluyendo la capitalización de las letras.
  • str1.toUpperCase() convierte str1 a todas las letras en mayúsculas ("HELLO").
  • str2.toUpperCase() convierte str2 a todas las letras en mayúsculas ("HELLO").
  • Luego usamos .equals() para comparar las versiones en mayúsculas de las cadenas, lo que efectivamente realiza una comparación sin distinción entre mayúsculas y minúsculas.

Guarda el archivo presionando Ctrl + S (o Cmd + S en Mac).

Ahora, compilemos y ejecutemos este programa en la Terminal. Asegúrate de estar en el directorio ~/project.

Compila el código:

javac StringCompare.java

Si no hay errores, se creará un archivo StringCompare.class.

Ahora, ejecuta el código compilado:

java StringCompare

Deberías ver la siguiente salida:

Case-sensitive comparison: false
Case-insensitive comparison using toUpperCase(): true

Esta salida demuestra que la comparación que distingue entre mayúsculas y minúsculas (equals()) devuelve false porque "Hello" y "hello" son diferentes debido a la capitalización, mientras que la comparación sin distinción entre mayúsculas y minúsculas utilizando toUpperCase() devuelve true porque ambas cadenas se convierten en "HELLO" cuando se convierten a mayúsculas.

Usar toUpperCase() (o toLowerCase()) antes de comparar cadenas es una forma común de realizar comparaciones sin distinción entre mayúsculas y minúsculas en Java.

Usar Character.isUpperCase() en un bucle

En el paso anterior, aprendimos cómo comparar cadenas (strings) completas sin distinguir entre mayúsculas y minúsculas. Ahora, exploremos cómo examinar caracteres individuales dentro de una cadena y determinar si son mayúsculas. Esto es útil cuando necesitas analizar la estructura de una cadena, como contar letras mayúsculas o validar el formato de entrada.

Java proporciona la clase Character, que tiene métodos útiles para trabajar con caracteres individuales. Uno de esos métodos es isUpperCase(), que verifica si un carácter dado es una letra mayúscula.

Modifiquemos nuestro archivo StringCompare.java para demostrar esto. Abre ~/project/StringCompare.java en el editor y reemplaza su contenido con el siguiente código:

public class StringCompare {
    public static void main(String[] args) {
        String text = "Hello World";
        int uppercaseCount = 0;

        System.out.println("Analyzing the string: \"" + text + "\"");

        // 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 uppercase
            if (Character.isUpperCase(character)) {
                System.out.println("Found an uppercase character: " + character + " at index " + i);
                uppercaseCount++; // Increment the counter
            }
        }

        System.out.println("Total uppercase characters found: " + uppercaseCount);
    }
}

Comprendamos las nuevas partes de este código:

  • Declaramos una variable de tipo String llamada text y una variable entera uppercaseCount inicializada en 0.
  • Usamos un bucle for para iterar a través de cada carácter de la cadena text. 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 i actual de la cadena.
  • Character.isUpperCase(character) verifica si el carácter es una letra mayúscula. Este método devuelve true si el carácter es mayúscula y false en caso contrario.
  • Si isUpperCase() devuelve true, imprimimos un mensaje que indica el carácter mayúscula y su índice, y aumentamos uppercaseCount.

Guarda el archivo (Ctrl + S).

Ahora, compila y ejecuta el programa modificado en la Terminal desde el directorio ~/project:

Compila:

javac StringCompare.java

Ejecuta:

java StringCompare

Deberías ver una salida similar a esta:

Analyzing the string: "Hello World"
Found an uppercase character: H at index 0
Found an uppercase character: W at index 6
Total uppercase characters found: 2

Esta salida muestra que nuestro programa identificó correctamente los caracteres mayúsculas 'H' y 'W' en la cadena y los contó.

Usar Character.isUpperCase() dentro de un bucle es una técnica poderosa para analizar cadenas carácter por carácter. En el siguiente paso, consideraremos cómo manejar los caracteres que no son letras.

Manejar caracteres no alfabéticos

En el paso anterior, usamos Character.isUpperCase() para identificar letras mayúsculas. Sin embargo, las cadenas (strings) pueden contener más que solo letras; pueden incluir números, símbolos, espacios y signos de puntuación. Al analizar cadenas, a menudo es necesario distinguir entre diferentes tipos de caracteres.

La clase Character proporciona otros métodos útiles para este propósito, como:

  • Character.isLetter(char ch): Verifica si un carácter es una letra.
  • Character.isDigit(char ch): Verifica si un carácter es un dígito (0 - 9).
  • Character.isWhitespace(char ch): Verifica si un carácter es un carácter de espacio en blanco (como espacio, tabulación, salto de línea).

Modifiquemos nuevamente nuestro archivo StringCompare.java para demostrar cómo manejar caracteres que no son letras y contar diferentes tipos de caracteres en una cadena. Abre ~/project/StringCompare.java en el editor y reemplaza su contenido con el siguiente código:

public class StringCompare {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int letterCount = 0;
        int digitCount = 0;
        int whitespaceCount = 0;
        int otherCount = 0;

        System.out.println("Analyzing the string: \"" + text + "\"");

        // 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 the type of the character
            if (Character.isLetter(character)) {
                letterCount++;
            } else if (Character.isDigit(character)) {
                digitCount++;
            } else if (Character.isWhitespace(character)) {
                whitespaceCount++;
            } else {
                otherCount++; // Characters that are not letters, digits, or whitespace
            }
        }

        System.out.println("Total characters: " + text.length());
        System.out.println("Letter count: " + letterCount);
        System.out.println("Digit count: " + digitCount);
        System.out.println("Whitespace count: " + whitespaceCount);
        System.out.println("Other character count: " + otherCount);
    }
}

En este código actualizado:

  • Inicializamos contadores para letras, dígitos, espacios en blanco y otros caracteres.
  • Dentro del bucle, usamos declaraciones if-else if-else para verificar el tipo de cada carácter utilizando Character.isLetter(), Character.isDigit() y Character.isWhitespace().
  • Incrementamos el contador correspondiente según el tipo de carácter.
  • Finalmente, imprimimos los recuentos de cada tipo de carácter.

Guarda el archivo (Ctrl + S).

Ahora, compila y ejecuta el programa en la Terminal desde el directorio ~/project:

Compila:

javac StringCompare.java

Ejecuta:

java StringCompare

Deberías ver una salida similar a esta:

Analyzing the string: "Hello World 123!"
Total characters: 16
Letter count: 10
Digit count: 3
Whitespace count: 2
Other character count: 1

Esta salida identifica y cuenta correctamente los diferentes tipos de caracteres en la cadena "Hello World 123!". Las letras son 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' (10 en total). Los dígitos son '1', '2', '3' (3 en total). Los caracteres de espacio en blanco son el espacio entre "Hello" y "World", y el espacio entre "World" y "123" (2 en total). El otro carácter es '!' (1 en total). El recuento total es 10 + 3 + 2 + 1 = 16, que coincide con la longitud de la cadena.

Al usar métodos como Character.isLetter(), Character.isDigit() y Character.isWhitespace(), puedes escribir un código más robusto que pueda manejar varios tipos de caracteres dentro de una cadena. Esto es crucial para tareas como validación de datos, análisis de entrada o análisis de texto.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si una cadena (string) está en mayúsculas en Java. Exploramos dos métodos principales. Primero, comparamos una cadena con su versión en mayúsculas utilizando el método toUpperCase() y el método equals() para realizar una comparación sin distinguir entre mayúsculas y minúsculas. Este método es útil para verificar si dos cadenas son iguales independientemente de su formato de mayúsculas y minúsculas.

En segundo lugar, aprendimos cómo iterar a través de una cadena y usar el método Character.isUpperCase() dentro de un bucle para verificar si cada carácter es una letra mayúscula. También consideramos cómo manejar los caracteres que no son letras durante este proceso, asegurándonos de que nuestra comprobación sea sólida. Estas técnicas proporcionan diferentes enfoques para determinar el estado de mayúsculas de una cadena según los requisitos específicos de la tarea.

Relacionado Java Cursos
Java para Principiantes

Java para Principiantes

java
Ejercicios de programación en Java

Ejercicios de programación en Java

java
Inserción masiva de datos en el horario de cursos

Inserción masiva de datos en el horario de cursos

java