Como Verificar se uma String Está em Minúsculas em Java - Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se uma string está em minúsculas em Java. Exploraremos diferentes métodos para alcançar isso, começando com a comparação de strings ignorando a capitalização usando toLowerCase() e equalsIgnoreCase().

Em seguida, você aprenderá como iterar por uma string e usar Character.isLowerCase() para verificar cada caractere individualmente. Finalmente, abordaremos como lidar com caracteres que não são letras ao realizar essa verificação.

Comparar String com toLowerCase()

Nesta etapa, aprenderemos como comparar strings em Java ignorando a capitalização das letras. Esta é uma tarefa comum quando você deseja verificar se duas strings são iguais, independentemente de usarem letras maiúsculas ou minúsculas.

Vamos criar um novo arquivo Java para praticar isso.

Abra o WebIDE se ele ainda não estiver aberto.
No Explorador de Arquivos à esquerda, certifique-se de estar no diretório ~/project.
Clique com o botão direito no espaço vazio no Explorador de Arquivos, selecione "Novo Arquivo" e nomeie-o CaseInsensitiveCompare.java.
Abra o arquivo CaseInsensitiveCompare.java no editor.

Copie e cole o seguinte código no 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);
    }
}

Neste código:

Declaramos três variáveis String: str1, str2 e str3.
str1.equals(str2) realiza uma comparação case-sensitive (sensível a maiúsculas e minúsculas). Retornará false porque "Hello" e "hello" são diferentes devido ao 'H' maiúsculo.
str1.equalsIgnoreCase(str2) realiza uma comparação case-insensitive (insensível a maiúsculas e minúsculas). Retornará true porque "Hello" e "hello" são iguais quando a capitalização é ignorada.
Também comparamos str1 e str3 ignorando a capitalização para mostrar que palavras diferentes ainda são consideradas diferentes.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project.
Compile o programa Java usando o comando javac:
```
javac CaseInsensitiveCompare.java
```
Se não houver erros, você não verá nenhuma saída. Um arquivo CaseInsensitiveCompare.class será criado no diretório ~/project.

Execute o programa Java compilado usando o comando java:

java CaseInsensitiveCompare

Você deve ver a seguinte saída:

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 saída confirma que equals() é case-sensitive, enquanto equalsIgnoreCase() ignora a capitalização.

Usar equalsIgnoreCase() é uma maneira conveniente de comparar strings sem se preocupar se as letras são maiúsculas ou minúsculas.

Usar Character.isLowerCase() em Loop

Na etapa anterior, aprendemos como comparar strings inteiras ignorando a capitalização. Às vezes, você pode precisar examinar caracteres individuais dentro de uma string e verificar se eles estão em minúsculas ou maiúsculas. Java fornece métodos úteis para isso na classe Character.

Nesta etapa, usaremos o método Character.isLowerCase() dentro de um loop para contar o número de letras minúsculas em uma string.

Abra o WebIDE se ele ainda não estiver aberto.
No Explorador de Arquivos à esquerda, certifique-se de estar no diretório ~/project.
Crie um novo arquivo chamado CountLowercase.java no diretório ~/project.
Abra o arquivo CountLowercase.java no editor.
Copie e cole o seguinte código no 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);
    }
}
```
Vamos analisar este código:
- Temos uma variável String chamada text contendo uma mistura de letras maiúsculas, letras minúsculas, números e símbolos.
- Inicializamos uma variável inteira lowercaseCount com 0. Esta variável armazenará a contagem de letras minúsculas.
- Usamos um loop for para iterar por cada caractere da string. O loop é executado do índice 0 até (mas sem incluir) o comprimento da string.
- text.charAt(i) obtém o caractere no índice atual i.
- Character.isLowerCase(character) é um método que retorna true se o character fornecido for uma letra minúscula e false caso contrário.
- Se Character.isLowerCase() retornar true, incrementamos lowercaseCount.
- Finalmente, imprimimos a string original e a contagem total de letras minúsculas.
Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project.
Compile o programa Java:
```
javac CountLowercase.java
```
Se a compilação for bem-sucedida, um arquivo CountLowercase.class será criado.
Execute o programa Java compilado:
```
java CountLowercase
```
Você deve ver a seguinte saída:
```
The string is: "Hello World 123!"
Number of lowercase letters: 8
```
A saída mostra que há 8 letras minúsculas na string "Hello World 123!" ('e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd').

Usar Character.isLowerCase() dentro de um loop permite que você execute uma análise caractere por caractere de uma string, o que é útil para várias tarefas de processamento de texto.

Ignorar Caracteres Não-Letras

Na etapa anterior, contamos as letras minúsculas. No entanto, strings podem conter vários caracteres, como números, espaços e símbolos. Ao comparar strings ou analisar seu conteúdo, você geralmente deseja ignorar esses caracteres não-letras.

Nesta etapa, modificaremos nosso programa para processar apenas caracteres de letras e ignorar todo o resto. Usaremos o método Character.isLetter() para isso.

Abra o WebIDE se ele ainda não estiver aberto.
Abra o arquivo CountLowercase.java que você criou na etapa anterior.

Modifique o código para incluir uma verificação para saber se um caractere é uma letra antes de verificar se ele está em minúsculas. Substitua o código existente pelo seguinte:

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);
    }
}

Aqui está o que adicionamos e alteramos:

Introduzimos um StringBuilder chamado lettersOnly. StringBuilder é usado para construir strings de forma eficiente, especialmente quando você está adicionando caracteres em um loop.
Dentro do loop, adicionamos uma condição if (Character.isLetter(character)). Isso verifica se o character atual é uma letra (maiúscula ou minúscula).
Se o caractere for uma letra, nós o anexamos ao StringBuilder lettersOnly usando lettersOnly.append(character).
A verificação Character.isLowerCase(character) agora está aninhada dentro da verificação Character.isLetter(), garantindo que contemos apenas letras minúsculas entre os caracteres que são realmente letras.
Finalmente, imprimimos a string original, a string contendo apenas letras e a contagem de letras minúsculas entre essas letras.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project.
Compile o programa Java modificado:
```
javac CountLowercase.java
```
Certifique-se de que não haja erros de compilação.
Execute o programa Java compilado:
```
java CountLowercase
```
Você deve ver a seguinte saída:
```
The original string is: "Hello World 123!"
Letters only string: "HelloWorld"
Number of lowercase letters (ignoring non-letters): 8
```
Observe que a "Letters only string" agora contém apenas "HelloWorld", e a contagem de minúsculas ainda é 8, pois estamos contando apenas letras minúsculas entre as letras reais.

Usar Character.isLetter() é muito útil quando você precisa filtrar caracteres não alfabéticos de uma string antes de processá-la ainda mais.

Resumo

Neste laboratório, aprendemos como verificar se uma string está em minúsculas em Java. Exploramos dois métodos principais. Primeiro, comparamos strings usando equalsIgnoreCase() para realizar comparações que ignoram a capitalização, demonstrando como verificar se duas strings são iguais, independentemente da capitalização das letras.

Segundo, embora os detalhes completos não tenham sido fornecidos, as etapas indicam que aprenderíamos a iterar por uma string usando um loop e utilizar Character.isLowerCase() para verificar se caracteres individuais estão em minúsculas, ao mesmo tempo em que consideramos como ignorar caracteres não-letras durante esse processo.