Praticando Java: Strings e Regex

Strings e regex - Strings

Olá! Meu nome é Jacqueline Oliveira, sou engenheira de software e instrutora na Alura.

Audiodescrição: Jacqueline se descreve como uma mulher de pele branca, com cabelos longos e reflexos louros. Veste uma blusa amarela e, ao fundo, há uma parede com iluminação azul.

Trabalhando com Strings no Java

No Java, existem diversos tipos de variáveis, como as de tipos primitivos, por exemplo, int e double, além das variáveis de texto, que são as strings. No entanto, no Java, as strings não são apenas tipos de dado; na verdade, elas são classes. A linguagem já fornece uma classe String com métodos e atributos que podem ser utilizados para manipulação de texto.

Vamos abrir a IDE para exemplificar. No código, já temos um método principal, o main.

package br.com.alura;

public class Principal {
    public static void main(String[] args) {
        String professor = "Jacqueline Oliveira";

        String disciplina = "Java e Programação Orientada a Objetos";

        String curriculo = ""
            + "Pós-graduada em Engenharia e "
            + "Arquitetura de Software; "
            + "Desenvolvedora backend Java desde 2010; "
            + "";

        String texto = String.format("Disciplina: %s - %s", disciplina, professor);
        System.out.println(texto);

        System.out.printf("Nome: %s %nDisciplina: %s", professor, disciplina);
    }
}

Para criar e atribuir uma variável do tipo String, seguimos a mesma lógica das variáveis primitivas: primeiro declaramos o tipo (String), depois o nome da variável. Neste caso, professor, seguido do operador de atribuição (=) e do valor desejado, que deve estar entre aspas duplas.

O mesmo processo foi aplicado à variável disciplina, que também recebeu um valor em aspas duplas.

Agora, observe a declaração da variável curriculo. Diferente das anteriores, ela foi atribuída utilizando três pares de aspas duplas, em vez de apenas uma abertura e um fechamento. Esse recurso é chamado de text block e permite formatar o conteúdo da String de maneira mais estruturada. Com ele, podemos incluir quebras de linha, ajustar espaçamentos e organizar o texto diretamente no código, facilitando sua leitura e exibição.

Como mencionamos, a variável String é, na verdade, uma classe. Se pressionarmos a tecla "Ctrl" no teclado e clicarmos sobre a palavra String no código, podemos acessar sua documentação. Nela, encontramos informações sobre os métodos disponíveis, as interfaces que implementa e outros detalhes.

No entanto, como pessoa desenvolvedora, você não precisa se preocupar com isso neste momento. Esses conceitos ficarão mais claros quando estudar orientação a objetos e classes. Por enquanto, o mais importante é compreender os recursos que podemos utilizar ao trabalhar com strings.

Formatando Strings

Um dos aspectos interessantes ao manipular strings é a formatação. Existem duas formas principais de modificar o conteúdo de uma String e aprimorar a exibição de textos: usando String.format() e printf(). Para exemplificar, já temos um exemplo no código, especificamente nas seguintes linhas:

        String texto = String.format("Disciplina: %s - %s", disciplina, professor);
        System.out.println(texto);

        System.out.printf("Nome: %s %nDisciplina: %s", professor, disciplina);

Criamos uma variável chamada texto e utilizamos o método String.format(), que pertence à classe String. Esse método permite definir o formato no qual a string será impressa. Aqui, utilizamos o marcador %s, que indica um espaço reservado para substituição por outro valor ou variável. Embora seja possível inserir um valor diretamente entre aspas duplas, isso não faria sentido, pois poderíamos simplesmente escrever o texto de forma convencional.

Neste primeiro exemplo, ao imprimir a variável texto, ela foi formatada para exibir primeiro a disciplina e, em seguida, o nome do professor.

No exemplo seguinte, utilizamos o printf() de forma muito semelhante: inserimos o nome, usamos o marcador %s, adicionamos uma quebra de linha com %n e, depois, imprimimos a disciplina.

Agora, vamos executar a aplicação para visualizar o resultado. Observe que, inicialmente, o programa exibe o que foi formatado com String.format():

Disciplina: Java e Programação Orientada a Objetos – Jaqueline Oliveira

Logo abaixo, imprime o resultado formatado com printf():

Nome: Jaqueline Oliveira

Disciplina: Java e Programação Orientada a Objetos

Essas são formas de manipular e formatar a saída do texto conforme desejado.

Além disso, se imprimirmos a variável curriculo com System.out.println("\n" + curriculo), veremos que os saltos de linha já estarão preservados, exatamente como foram programados.

Retorno omitido.

Conhecendo os Especificadores de Formatação

Além de formatar, é importante conhecer os diferentes especificadores que podemos utilizar. No exemplo anterior, usamos %s para substituir uma variável de texto, mas há outros caracteres de formatação disponíveis. Por exemplo:

Conhecendo os Métodos para Manipulação de Strings

Além das opções de formatação, a classe String também oferece diversos métodos para manipulação de texto. Um exemplo útil é o método trim(), que remove espaços em branco no início e no final da string.

Suponha que, ao cadastrar o texto "Java e Programação Orientada a Objetos" no back-end, tenha sido adicionado um excesso de espaços ao redor. Isso afetaria a exibição, deixando a saída desalinhada, como no seguinte exemplo:

Disciplina:      Java e Programação Orientada a Objetos      – Jaqueline Oliveira

Para corrigir isso, podemos aplicar o método trim() diretamente na variável disciplina dentro da linha onde utilizamos String.format(). Assim, em vez de apenas disciplina, usamos disciplina.trim().

Disciplina: Java e Programação Orientada a Objetos – Jaqueline Oliveira

Ao executar o código novamente, os espaços extras são removidos automaticamente, garantindo uma saída mais limpa e bem formatada, independentemente de como o texto foi armazenado originalmente.

Outros métodos úteis para manipulação de strings são toLowerCase() e toUpperCase(), que convertem um texto para letras minúsculas ou maiúsculas, respectivamente.

Para demonstrar, aplicaremos o método toUpperCase() ao nome do professor. Onde utilizamos a variável professor, basta modificar o código para professor.toUpperCase(). Isso fará com que o nome seja exibido completamente em maiúsculas.

Ao executar a aplicação, o resultado será:

JAQUELINE OLIVEIRA

A classe String também oferece o método replace(), que permite substituir partes do texto por outro valor. Suponha que eu queira substituir "Oliveira" por "Magalhães". Para isso, na linha onde utilizamos printf(), aplicamos professor.replace("Oliveira", "Magalhães").

Se executarmos a aplicação novamente, veremos que o nome foi atualizado corretamente na saída:

Jaqueline Magalhães

Dessa forma, o texto já é impresso com a modificação desejada sem alterar a variável original.

Há diversos métodos disponíveis para manipulação de strings. Alguns dos mais úteis incluem:

• charAt() – Retorna o caractere de uma posição específica na string.
• substring() – Permite extrair um trecho da string, podendo definir tanto a posição inicial quanto a final. Por exemplo, substring(0, 10).
• contains() – Verifica se uma determinada palavra ou sequência de caracteres está presente na string.
• startsWith() – Confere se a string começa com um determinado conjunto de caracteres. Por exemplo, professor.startsWith("Jac") retornará true se o nome começar com "Jac".
• endsWith() – Similar ao startsWith, mas verifica se a string termina com um determinado sufixo.

Conclusão e Próximos Passos

Esses são apenas alguns exemplos dos muitos métodos disponíveis para manipulação de strings. Recomendamos que você pratique bastante, explore diferentes formas de utilização e teste modificações para consolidar seu aprendizado.

Se tiver qualquer dúvida, não hesite em nos contatar pelo fórum ou pelo Discord.

Esperamos que tenha aproveitado este conteúdo! Em breve, abordaremos *expressões regulares!

Strings e regex - Expressões regulares

Dando continuidade aos nossos estudos sobre string, vamos agora explorar uma ferramenta poderosa, conhecida como regex.

O Que é Regex?

Regex é a abreviação de expressões regulares. Anteriormente, vimos que é possível usar em uma string o método contains para verificar a presença de um texto específico. No entanto, o método contains não é suficiente quando precisamos verificar padrões mais complexos, como um número de telefone, CPF ou e-mail.

Exemplo Prático de Uso de Regex

Criando a Variável de Texto

Vamos exemplificar para tornar isso mais claro. Ao abrir nossa IDE, temos apenas o método main, e vamos criar uma variável chamada texto, do tipo String, e atribuir a ela o seguinte valor: "Meu e-mail é jacqueline@gmail.com".

public class Principal {
    public static void main(String[] args){
        String texto = "Meu email é jacqueline@gmail.com";
    }
}

Definindo um Padrão com Pattern

Como verificaríamos se dentro desse texto, que poderia conter milhões de linhas, há um padrão de e-mail? Não podemos procurar por "@gmail.com" especificamente, pois pode ser que o e-mail seja de outro provedor, como Yahoo, iCloud ou um corporativo, como "@alura.com.br". Portanto, precisamos usar um padrão, e é aí que entra a API Regex do Java, que nos ajudará a criar uma expressão regular para localizar um e-mail.

Para isso, utilizaremos duas classes que trabalham em conjunto: Pattern, onde determinamos o padrão da nossa expressão regular, e Matcher, que verifica se o padrão está presente no texto. Vamos criar um Pattern e chamá-lo de pattern, onde definiremos nosso padrão.

import java.util.regex.Pattern;
Pattern pattern =

Este padrão pode ser um pouco complexo, mas vamos começar com algo simples. Para criar, utilizamos Pattern.compile(), e declaramos nossa regex. Para reconhecer um e-mail, precisamos de um grupo de caracteres alfanuméricos, seguido por um arroba, mais outro grupo de caracteres alfanuméricos, um ponto, e mais um grupo.

Dentro da expressão, usamos um escape, que são duas barras invertidas (\\), seguida de w+, que indica a necessidade de pelo menos uma ocorrência de um caractere alfanumérico. Depois, temos um caractere literal, o arroba (@), que é essencial em qualquer e-mail.

Novamente, usamos o escape (\\) para incluir a expressão, seguido de w+ e um ponto literal (.). Por fim, incluímos mais um escape (\\) com outro w+ Isso indica que teremos um grupo de caracteres alfanuméricos.

import java.util.regex.Pattern;

public class Principal {
    public static void main(String[] args){
        String texto = "Meu email é jacqueline@gmail.com";
        Pattern pattern = Pattern.compile("\\w+@\\w+.\\w+")
    }
}

Este é nosso padrão inicial para identificar um e-mail. Embora existam padrões mais complexos, este nos atende por enquanto.

Verificando Correspondências com Matcher

Após criar o padrão, precisamos verificar se há alguma estrutura no texto que corresponda a ele. É aí que entra o Matcher. Vamos criar um Matcher chamado matcher.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Principal {
  public static void main(String[] args){
    String texto = "Meu email é jacqueline@gmail.com";
    Pattern pattern = Pattern.compile("\\w+@\\w+.\\w+");
    Matcher matcher = 
        
  }
}

Com o Matcher, aplicamos nosso padrão ao texto usando pattern.matcher(texto). Uma vez aplicado o padrão, verificamos se ele encontrou algo e solicitamos que nos traga o resultado.

Se matcher.find() retornar verdadeiro, imprimimos o resultado com System.out.println(matcher.group()). O método group sintetiza o resultado e nos traz o que foi encontrado.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Principal {
  public static void main(String[] args){
    String texto = "Meu email é jacqueline@gmail.com";
    Pattern pattern = Pattern.compile("\\w+@\\w+.\\w+");
    Matcher matcher = pattern.matcher(texto);
        
    if (matcher.find()) {
        System.out.println(matcher.group());
    }
  }
}

Ao executar, ele imprime "jacqueline@gmail.com".

Se alterarmos para "alura.com" , ele ainda reconhecerá e retornará o e-mail. Se mudarmos para "alura.com.br", ele retorna até "alura.com", mas corta o ".br", pois nosso padrão não o contempla, embora possa ser incluído posteriormente como opcional. Assim, montamos expressões regulares.

Elementos e Caracteres Especiais em Regex

O que significa cada elemento da expressão? Por que usamos w e o escape? Temos uma tabela que mostra todos os caracteres especiais:

Se precisarmos de dígitos de 0 a 9, ou qualquer caractere que não seja um dígito, usamos D maiúsculo. Para caracteres alfanuméricos, usamos w minúsculo. Se quisermos qualquer caractere que não seja alfanumérico, usamos W maiúsculo.

Existem vários caracteres especiais que podemos utilizar, além de classes de caracteres, onde definimos caracteres específicos que poderíamos usar. Quando utilizamos colchetes em expressões regulares, qualquer caractere dentro deles, como A, B ou C, será considerado. Se utilizarmos o acento circunflexo ^, significa qualquer caractere, exceto os especificados. Existem várias combinações possíveis ao trabalhar com regex para criar o padrão desejado.

Além disso, temos os quantificadores, que indicam, por exemplo, que deve haver zero ou mais ocorrências, ou pelo menos uma ou mais ocorrências. Por isso, utilizamos \w+, onde \w representa um caractere alfanumérico e o sinal de mais indica uma ou mais ocorrências. Podemos definir um número exato de ocorrências dentro dos colchetes ou especificar ocorrências opcionais, como N ou mais ocorrências. Há diversas combinações possíveis.

Na classe Matcher, temos métodos como find, que verifica se ocorreu uma correspondência, e group, que agrupa e exibe as ocorrências. Outros métodos incluem matches, lookingAt e replaceAll, que encontram e substituem padrões.

A classe oferece várias opções que podemos utilizar. Por ser uma classe Java, podemos consultar o Javadoc para exemplos. Basta clicar com a tecla "Ctrl" pressionada para acessar a classe e verificar seus métodos e possibilidades.

Formatando Telefones com Regex

Vamos demonstrar um exemplo de formatação de telefone, onde passamos um número sem formatação e ele retorna formatado.

Para isso, criamos um método chamado formatarTelefone, que retorna uma string formatada. A regex está estruturada para capturar grupos específicos do número de telefone:

• Grupo 1 (DDD): Dois dígitos (\\d{2});
• Grupo 2 (Parte principal): Quatro ou cinco dígitos ((\\d{4,5})), que podem representar telefones fixos ou celulares;
• Grupo 3 (Sufixo): Quatro dígitos finais ((\\d{4})).

Diferentemente da validação de e-mail (onde usamos um único grupo), aqui usamos os parênteses para definir grupos separados e permitir a formatação personalizada.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Principal {
    public static void main(String[] args) {
        String texto = "Meu email é jacqueline@gmail.com";
        Pattern pattern = Pattern.compile("\\w+@\\w+.\\w+");
        Matcher matcher = pattern.matcher(texto);

        if (matcher.find()) {
            System.out.println(matcher.group());
        }
    }

    public static String formatarTelefone(String telefone) {
        String regex = "(\\d{2})(\\d{4,5})(\\d{4})";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(telefone);

        if (matcher.matches()) {
            return String.format("(%s) %s-%s", matcher.group(1), matcher.group(2), matcher.group(3));
        }

        return "Número de telefone inválido!";
    }
}

Ao chamar System.out.println com formatarTelefone, passamos um número sem formatação, como 2199887744, e ele deve retornar formatado.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Principal {
    public static void main(String[] args) {
        String texto = "Meu email é jacqueline@gmail.com";
        Pattern pattern = Pattern.compile("\\w+@\\w+.\\w+");
        Matcher matcher = pattern.matcher(texto);

        if (matcher.find()) {
            System.out.println(matcher.group());
        }
            
            System.out.println(formatarTelefone("2199887744"));
    }

    public static String formatarTelefone(String telefone) {
        String regex = "(\\d{2})(\\d{4,5})(\\d{4})";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(telefone);

        if (matcher.matches()) {
            return String.format("(%s) %s-%s", matcher.group(1), matcher.group(2), matcher.group(3));
        }

        return "Número de telefone inválido!";
    }
}

Ao executar, é retornado o e-mail com o telefone formatado:

jacqueline@alura.com

(21) 9988-7744

Conclusão e Recursos Adicionais

As expressões regulares são extremamente úteis e valem a pena serem aprofundadas. Embora possam parecer complicadas, ferramentas de inteligência artificial e sites como o regex101 ajudam na criação e validação de padrões.

No site regex101.com, podemos escolher Java e testar expressões regulares, como a utilizada para e-mails. Primeiro, inserimos a expressão "\\w+@\\w+.\\w+" no campo "REGULAR EXPRESSION" e, em seguida, inserimos o texto "Meu e-mail é jac@gmail.com" no campo "TEST STRING".

Ao fazer isso, o site sublinha o padrão "jac@gmail.com". Se alterarmos o texto para "Meu e-mail é jac@gmail.com e do meu amigo é joao@icloud.com", ele sublinhará os dois e-mails, "jac@gmail.com" e "joao@icloud.com", identificados como padrão.

Esperamos que este conteúdo tenha sido útil. É importante praticar ao trabalhar com strings. Em caso de dúvidas, entre em contato pelo fórum ou Discord. Disponibilizamos um curso em nossa plataforma que aprofunda o conhecimento em regex, embora não seja em Java.

Até o próximo curso!

Sobre o curso Praticando Java: Strings e Regex

O curso Praticando Java: Strings e Regex possui 26 minutos de vídeos, em um total de 16 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Strings e regex