Como Verificar se um Caractere é Maiúsculo em Java - Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se um caractere é uma letra maiúscula em Java. Exploraremos o método Character.isUpperCase(), uma ferramenta conveniente fornecida pela classe Character para essa finalidade.

Através de exemplos práticos, você verá como usar Character.isUpperCase() com vários caracteres, incluindo maiúsculas, minúsculas e caracteres não-letra, para entender seu comportamento e determinar efetivamente se um determinado caractere é maiúsculo em seus programas Java.

Usar o Método Character.isUpperCase()

Nesta etapa, exploraremos como determinar se um caractere é uma letra maiúscula em Java usando o método Character.isUpperCase(). Este método faz parte da classe Character, que fornece métodos úteis para trabalhar com caracteres individuais.

O método Character.isUpperCase() é um método estático, o que significa que você pode chamá-lo diretamente na própria classe Character, sem precisar criar um objeto da classe. Ele recebe um único caractere como argumento e retorna true se o caractere for uma letra maiúscula e false caso contrário.

Vamos criar um programa Java simples para demonstrar como usar este método.

Abra o arquivo HelloJava.java no editor WebIDE, caso ele ainda não esteja aberto.

Substitua o código existente pelo seguinte:

public class HelloJava {
    public static void main(String[] args) {
        char char1 = 'A';
        char char2 = 'b';
        char char3 = '7';

        boolean isUpper1 = Character.isUpperCase(char1);
        boolean isUpper2 = Character.isUpperCase(char2);
        boolean isUpper3 = Character.isUpperCase(char3);

        System.out.println("Is '" + char1 + "' uppercase? " + isUpper1);
        System.out.println("Is '" + char2 + "' uppercase? " + isUpper2);
        System.out.println("Is '" + char3 + "' uppercase? " + isUpper3);
    }
}

Neste código:

Declaramos três variáveis char: char1, char2 e char3, e atribuímos a elas caracteres diferentes.
Usamos Character.isUpperCase() para verificar se cada caractere é maiúsculo e armazenamos o resultado em variáveis booleanas (isUpper1, isUpper2, isUpper3).
Finalmente, imprimimos os resultados no console.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Is 'A' uppercase? true
Is 'b' uppercase? false
Is '7' uppercase? false
```
Esta saída confirma que Character.isUpperCase() identificou corretamente 'A' como maiúsculo e 'b' e '7' como não maiúsculos.

Testar com Caracteres de Casos Mistos

Na etapa anterior, usamos Character.isUpperCase() com caracteres individuais. Agora, vamos ver como podemos aplicar este método a uma string contendo uma mistura de caracteres maiúsculos e minúsculos. Isso nos ajudará a entender como iterar por uma string e verificar o caso de cada caractere.

Uma string em Java é uma sequência de caracteres. Podemos acessar caracteres individuais em uma string usando o método charAt(), que recebe um índice (posição) como argumento. O índice começa em 0 para o primeiro caractere.

Vamos modificar nosso programa para verificar o caso dos caracteres em uma string.

Abra o arquivo HelloJava.java no editor WebIDE.
Substitua o código existente pelo seguinte:
```
public class HelloJava {
    public static void main(String[] args) {
        String testString = "Hello Java 123";

        System.out.println("Checking characters in the string: \"" + testString + "\"");

        for (int i = 0; i < testString.length(); i++) {
            char currentChar = testString.charAt(i);
            boolean isUpper = Character.isUpperCase(currentChar);
            System.out.println("Character '" + currentChar + "' at index " + i + " is uppercase? " + isUpper);
        }
    }
}
```
Neste código atualizado:
- Definimos uma variável String chamada testString com uma mistura de letras maiúsculas, letras minúsculas, espaços e números.
- 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.
- Dentro do loop, testString.charAt(i) obtém o caractere no índice atual i.
- Em seguida, usamos Character.isUpperCase() para verificar se currentChar é maiúsculo.
- Finalmente, imprimimos o caractere, seu índice e o resultado da verificação de maiúsculas.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```

Execute o programa compilado:

java HelloJava

Você deve ver uma saída semelhante a esta, mostrando o resultado para cada caractere na string:

Checking characters in the string: "Hello Java 123"
Character 'H' at index 0 is uppercase? true
Character 'e' at index 1 is uppercase? false
Character 'l' at index 2 is uppercase? false
Character 'l' at index 3 is uppercase? false
Character 'o' at index 4 is uppercase? false
Character ' ' at index 5 is uppercase? false
Character 'J' at index 6 is uppercase? true
Character 'a' at index 7 is uppercase? false
Character 'v' at index 8 is uppercase? false
Character 'a' at index 9 is uppercase? false
Character ' ' at index 10 is uppercase? false
Character '1' at index 11 is uppercase? false
Character '2' at index 12 is uppercase? false
Character '3' at index 13 is uppercase? false

Isso demonstra como Character.isUpperCase() funciona quando aplicado a caracteres extraídos de uma string, identificando corretamente 'H' e 'J' como maiúsculos.

Ignorar Caracteres Não-Letras

Na etapa anterior, vimos que Character.isUpperCase() retorna false para caracteres que não são letras, como espaços e números. Frequentemente, ao analisar texto, estamos interessados apenas nas letras e queremos ignorar outros caracteres.

A classe Character fornece outro método útil, Character.isLetter(), que retorna true se um caractere é uma letra (maiúscula ou minúscula) e false caso contrário. Podemos combinar Character.isLetter() e Character.isUpperCase() para verificar se um caractere é uma letra maiúscula e ignorar caracteres que não são letras.

Vamos modificar nosso programa para contar o número de letras maiúsculas na string, ignorando espaços, números e outros caracteres não-letras.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua o código existente pelo seguinte:

public class HelloJava {
    public static void main(String[] args) {
        String testString = "Hello Java 123";
        int uppercaseCount = 0;

        System.out.println("Counting uppercase letters in the string: \"" + testString + "\"");

        for (int i = 0; i < testString.length(); i++) {
            char currentChar = testString.charAt(i);

            // Check if the character is a letter AND if it is uppercase
            if (Character.isLetter(currentChar) && Character.isUpperCase(currentChar)) {
                uppercaseCount++;
                System.out.println("Found uppercase letter: '" + currentChar + "' at index " + i);
            }
        }

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

Neste código:

Inicializamos uma variável inteira uppercaseCount com 0.
Dentro do loop, adicionamos uma condição if: if (Character.isLetter(currentChar) && Character.isUpperCase(currentChar)). O operador && significa "e". Esta condição é verdadeira somente se ambos Character.isLetter(currentChar) for verdadeiro e Character.isUpperCase(currentChar) for verdadeiro.
Se a condição for verdadeira, incrementamos uppercaseCount e imprimimos uma mensagem indicando que uma letra maiúscula foi encontrada.
Após o término do loop, imprimimos a contagem total de letras maiúsculas.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Counting uppercase letters in the string: "Hello Java 123"
Found uppercase letter: 'H' at index 0
Found uppercase letter: 'J' at index 6
Total uppercase letters found: 2
```
Esta saída mostra que nosso programa identificou e contou corretamente apenas as letras maiúsculas ('H' e 'J'), ignorando as letras minúsculas, espaços e números.

Resumo

Neste laboratório, aprendemos como verificar se um caractere é maiúsculo em Java usando o método estático Character.isUpperCase(). Este método recebe um único caractere como entrada e retorna um valor booleano indicando se o caractere é uma letra maiúscula. Demonstramos seu uso com um programa Java simples, testando-o com caracteres maiúsculos, minúsculos e não-letras para observar os resultados booleanos retornados.