Como Verificar se uma String Começa com um Prefixo em Java | Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se uma string começa com um prefixo específico em Java usando o método startsWith(). Este exercício prático irá guiá-lo através da aplicação do método startsWith(), testando seu comportamento com diferentes casos e entendendo como ele lida com prefixos nulos e vazios. Ao final deste laboratório, você estará proficiente no uso desta técnica fundamental de manipulação de strings.

Aplicar startsWith() para Verificar o Prefixo

Nesta etapa, você aprenderá como usar o método startsWith() em Java para verificar se uma string começa com um prefixo específico. Esta é uma operação comum quando você precisa processar texto com base em como ele começa.

O método startsWith() faz parte da classe String em Java. Ele recebe um argumento String, que é o prefixo que você deseja verificar. Ele retorna true se a string começar com o prefixo especificado e false caso contrário.

Vamos criar um novo arquivo Java para praticar o uso de startsWith().

Abra o Explorador de Arquivos no lado esquerdo da WebIDE.
Clique com o botão direito do mouse no diretório ~/project e selecione "Novo Arquivo".
Nomeie o novo arquivo PrefixChecker.java.
Abra PrefixChecker.java no editor e cole o seguinte código:
```
public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";
        String prefix = "Hello";

        boolean startsWithPrefix = text.startsWith(prefix);

        System.out.println("Does the text start with '" + prefix + "'? " + startsWithPrefix);
    }
}
```
Neste código:
- Declaramos uma variável String chamada text e a inicializamos com "Hello, Java!".
- Declaramos outra variável String chamada prefix e a inicializamos com "Hello".
- Chamamos o método startsWith() na string text, passando prefix como argumento. O resultado (true ou false) é armazenado na variável boolean startsWithPrefix.
- Finalmente, imprimimos o resultado no console.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, vamos compilar e executar este programa. Abra o Terminal na parte inferior da WebIDE. Certifique-se de estar no diretório ~/project.
Compile o arquivo Java usando o comando javac:
```
javac PrefixChecker.java
```
Se não houver erros, este comando criará um arquivo PrefixChecker.class no diretório ~/project.
Execute o programa compilado usando o comando java:
```
java PrefixChecker
```
Você deve ver a seguinte saída:
```
Does the text start with 'Hello'? true
```
Esta saída confirma que a string "Hello, Java!" realmente começa com o prefixo "Hello".

Testar Prefixo com Diferentes Casos

Na etapa anterior, você usou com sucesso startsWith() para verificar um prefixo. Agora, vamos explorar como startsWith() lida com diferentes casos (letras maiúsculas e minúsculas).

Por padrão, o método startsWith() é case-sensitive (sensível a maiúsculas e minúsculas). Isso significa que "Hello" é considerado diferente de "hello" ou "HELLO". Vamos modificar nosso arquivo PrefixChecker.java para ver isso em ação.

Abra o arquivo PrefixChecker.java no editor da WebIDE.

Modifique o método main para incluir verificações com diferentes casos. Substitua o método main existente pelo seguinte código:

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefix1 = "Hello";
        String prefix2 = "hello";
        String prefix3 = "HELLO";

        boolean startsWithPrefix1 = text.startsWith(prefix1);
        boolean startsWithPrefix2 = text.startsWith(prefix2);
        boolean startsWithPrefix3 = text.startsWith(prefix3);

        System.out.println("Does the text start with '" + prefix1 + "'? " + startsWithPrefix1);
        System.out.println("Does the text start with '" + prefix2 + "'? " + startsWithPrefix2);
        System.out.println("Does the text start with '" + prefix3 + "'? " + startsWithPrefix3);
    }
}

Neste código atualizado, estamos verificando se a string text começa com "Hello", "hello" e "HELLO".

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal e certifique-se de estar no diretório ~/project.
Compile o arquivo Java modificado:
```
javac PrefixChecker.java
```
Execute o programa compilado:
```
java PrefixChecker
```
Você deve ver a seguinte saída:
```
Does the text start with 'Hello'? true
Does the text start with 'hello'? false
Does the text start with 'HELLO'? false
```
Esta saída mostra claramente que startsWith() retornou true apenas para o prefixo "Hello" (correspondendo ao caso da string original) e false para "hello" e "HELLO". Isso demonstra que startsWith() é case-sensitive.

Se você precisar realizar uma verificação de prefixo case-insensitive (insensível a maiúsculas e minúsculas), normalmente converteria tanto a string original quanto o prefixo para o mesmo caso (minúsculo ou maiúsculo) antes de usar startsWith(). Por exemplo, você poderia usar text.toLowerCase().startsWith(prefix.toLowerCase()). Não implementaremos isso aqui, mas é uma técnica útil para ter em mente.

Verificar Prefixos Nulos e Vazios

Nesta etapa, investigaremos como o método startsWith() se comporta quando o prefixo é null ou uma string vazia (""). Entender esses casos extremos é importante para escrever código robusto.

Abra o arquivo PrefixChecker.java no editor da WebIDE.

Modifique o método main para testar com um prefixo null e um prefixo de string vazia. Substitua o método main existente pelo seguinte código:

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefixNull = null;
        String prefixEmpty = "";

        // Check with a null prefix
        try {
            boolean startsWithPrefixNull = text.startsWith(prefixNull);
            System.out.println("Does the text start with null? " + startsWithPrefixNull);
        } catch (NullPointerException e) {
            System.out.println("Checking with null prefix resulted in: " + e);
        }

        // Check with an empty prefix
        boolean startsWithPrefixEmpty = text.startsWith(prefixEmpty);
        System.out.println("Does the text start with an empty string? " + startsWithPrefixEmpty);
    }
}

Neste código atualizado:

Declaramos prefixNull e o definimos como null.
Declaramos prefixEmpty e o definimos como uma string vazia "".
Usamos um bloco try-catch ao verificar com prefixNull. Isso ocorre porque tentar chamar um método em um objeto null em Java resulta em uma NullPointerException. Capturamos essa exceção para ver o que acontece.
Verificamos com o prefixo de string vazia prefixEmpty.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal e certifique-se de estar no diretório ~/project.
Compile o arquivo Java modificado:
```
javac PrefixChecker.java
```
Execute o programa compilado:
```
java PrefixChecker
```
Você deve ver a seguinte saída:
```
Checking with null prefix resulted in: java.lang.NullPointerException
Does the text start with an empty string? true
```
Esta saída demonstra dois pontos importantes:
- Passar null como prefixo para startsWith() resulta em uma NullPointerException. É por isso que é crucial lidar com possíveis valores null antes de chamar métodos neles.
- Passar uma string vazia ("") como prefixo para startsWith() retorna true. Isso ocorre porque qualquer string pode ser considerada como começando com uma string vazia.

Entender como startsWith() lida com null e strings vazias é importante para evitar erros e escrever a lógica correta em seus programas Java.

Resumo

Neste laboratório, você aprendeu a usar o método startsWith() em Java para verificar se uma string começa com um prefixo específico. Você praticou a aplicação deste método criando um programa Java simples, compilando-o e executando-o para ver a saída. Essa habilidade fundamental é essencial para várias tarefas de manipulação de strings na programação Java.

Como Verificar se uma String Começa com um Prefixo Específico em Java

Introdução

Aplicar startsWith() para Verificar o Prefixo

Testar Prefixo com Diferentes Casos

Verificar Prefixos Nulos e Vazios

Resumo