Aprendendo Java do Zero - Parte 5: Strings

#Java

Este é o quinto artigo da série Aprendendo Java do Zero. Na Parte 1, escrevemos nosso primeiro "Hello World". Na Parte 2, montamos um ambiente de desenvolvimento local completo. Na Parte 3, aprendemos a declarar variáveis e conhecemos os oito tipos primitivos de dados. E na Parte 4, conhecemos os cinco grupos de operadores da linguagem.

Com variáveis, tipos e operadores no repertório, chegou a hora de trabalhar com um dos tipos de referência mais usados em Java: String. Neste artigo, nós vamos:

entender o que é uma String e as duas formas de criá-la;
aprender a formatar uma String;
obter o tamanho de uma String e verificar se ela está vazia;
dividir uma String em partes e juntar partes de volta em uma única String;
converter uma String para maiúsculas ou minúsculas;
comparar o conteúdo de duas Strings corretamente;
substituir caracteres ou trechos dentro de uma String;
verificar se uma String contém determinada substring.

Como trabalhar com Strings em Java

Uma String é uma sequência de caracteres formando um texto. Diferente dos oito tipos primitivos que vimos na Parte 3, String é um tipo de referência.

Existem duas formas de criar uma String. A forma literal:

public class Main {
  public static void main(String[] args) {
      String nome = "João";

      System.out.println("Meu nome é " + nome + ".");
  }
}

E a forma usando o operador new:

public class Main {
  public static void main(String[] args) {
      String nome = new String("João");

      System.out.println("Meu nome é " + nome + ".");
  }
}

As duas funcionam de forma equivalente na prática, mas existe uma diferença de bastidores: a JVM mantém uma área de memória reservada para strings, chamada string pool. Ao criar uma string de forma literal, a JVM primeiro verifica se aquele texto já existe no pool; se existir, reaproveita, se não, cria. Já com new, a JVM sempre cria um novo objeto, mesmo que o mesmo texto já exista no pool.

public class Main {
  public static void main(String[] args) {
      String literal1 = "abc";
      String literal2 = "abc";

      String objeto1 = new String("abc");
      String objeto2 = new String("abc");

      System.out.println(literal1 == literal2); // true
      System.out.println(objeto1 == objeto2);   // false
  }
}

O operador == compara se são exatamente o mesmo objeto na memória, e é por isso que o resultado muda entre os dois casos. Vamos voltar a esse detalhe mais adiante, quando falarmos sobre como comparar Strings corretamente.

Como formatar uma String

Concatenar com +, como fizemos até aqui, funciona bem para casos simples, mas fica difícil de ler quando há muitas partes envolvidas. Uma alternativa mais legível é String.format():

public class Main {
  public static void main(String[] args) {
      String nome = "João";
      int idade = 56;

      String textoFormatado = String.format("Meu nome é %s e tenho %d anos.", nome, idade);

      System.out.println(textoFormatado);
  }
}

%s e %d são especificadores de formato: eles marcam onde cada argumento seguinte deve ser inserido, na ordem em que aparecem. A ordem dos especificadores precisa bater com a ordem dos argumentos, e o tipo de cada argumento precisa bater com o tipo esperado pelo especificador.

Especificadores comuns:

%b, %B — booleano
%s, %S — string
%c, %C — caractere Unicode
%d — inteiro decimal
%f — número de ponto flutuante (float ou double)

Como obter o tamanho de uma String ou verificar se está vazia

Todo objeto String tem o método length(), que devolve seu tamanho:

public class Main {
  public static void main(String[] args) {
      String nome = "João";

      System.out.println(String.format("O tamanho dessa string é: %d.", nome.length())); // 4
  }
}

Para verificar se está vazia, use isEmpty():

public class Main {
  public static void main(String[] args) {
      String nome = "João";

      if (nome.isEmpty()) {
          System.out.println("Nenhum nome foi informado");
      } else {
          System.out.println(String.format("Certo, vou cuidar de %s.", nome));
      }
  }
}

Como dividir e juntar Strings

O método split() divide uma string com base em um separador (ou expressão regular):

import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
      String nome = "João Silva Professor";

      System.out.println(Arrays.toString(nome.split(" ")));
  }
}

O resultado é um array de strings: [João, Silva, Professor].

Para juntar de volta, use String.join():

public class Main {
  public static void main(String[] args) {
      String nome = "João Silva Professor";

      String[] partes = nome.split(" ");

      String nomeJuntado = String.join(" ", partes);

      System.out.println(nomeJuntado); // João Silva Professor
  }
}

String.join() também funciona diretamente com strings soltas, fora de um array:

public class Main {
  public static void main(String[] args) {
      System.out.println(String.join(" ", "João", "Silva", "Professor"));
  }
}

Como converter uma String para maiúsculas ou minúsculas

public class Main {
  public static void main(String[] args) {
      String nome = "João Silva";

      System.out.println(nome.toUpperCase()); // JOÃO SILVA
      System.out.println(nome.toLowerCase()); // joão silva
  }
}

Como comparar duas Strings

Como vimos no início do artigo, strings são tipos de referência. Isso significa que comparar com == compara se é o mesmo objeto na memória, não se o conteúdo é igual. Para comparar conteúdo, use equals() (sensível a maiúsculas e minúsculas) ou equalsIgnoreCase() (insensível a maiúsculas e minúsculas):

public class Main {
  public static void main(String[] args) {
      String nome = "João Silva";
      String nomeMaiusculo = nome.toUpperCase();

      System.out.println(nome.equals(nomeMaiusculo));           // false
      System.out.println(nome.equalsIgnoreCase(nomeMaiusculo)); // true
  }
}

⚠️ Por que não usar == para comparar Strings?

O motivo de fundo é o mesmo do exemplo do string pool, lá no início do artigo: duas variáveis podem guardar exatamente o mesmo texto e, ainda assim, apontar para objetos diferentes na memória. Quando isso acontece, == retorna false, mesmo com o conteúdo idêntico.

public class Main {
  public static void main(String[] args) {
      String nome1 = "João";
      String nome2 = new String("João");

      System.out.println(nome1 == nome2);      // false, objetos diferentes
      System.out.println(nome1.equals(nome2)); // true, mesmo conteúdo
  }
}

O problema é que, em código real, você raramente sabe com certeza se uma string veio de um literal, de uma leitura de arquivo, de uma resposta de banco de dados ou de uma concatenação em tempo de execução, e cada um desses casos pode ou não resultar no mesmo objeto do string pool. Depender de == significa depender de um detalhe de implementação que pode mudar o comportamento do programa sem qualquer aviso do compilador. Por isso, a prática recomendada é: == para saber se é o mesmo objeto, equals() (ou equalsIgnoreCase()) para saber se é o mesmo conteúdo, que é quase sempre o que se quer ao comparar strings.

💡 Bônus: a notação YODA

Um erro comum ao comparar uma String com um valor fixo é escrever a variável primeiro:

String comando = null;

if (comando.equals("sair")) {
  System.out.println("Encerrando o programa.");
}

Se comando for null, essa linha lança uma NullPointerException, porque o programa tenta chamar um método (equals) em cima de um objeto que não existe.

Uma forma de resolver isso é checar null explicitamente, antes de chamar equals():

String comando = null;

if (comando != null && comando.equals("sair")) {
  System.out.println("Encerrando o programa.");
}

Isso funciona, mas depende de lembrar de escrever comando != null && toda vez que houver risco de comando ser null. Esquecer essa checagem uma única vez já é suficiente para o programa quebrar em tempo de execução.

Uma técnica bastante usada por programadores mais experientes para evitar depender dessa checagem manual é inverter a ordem da comparação, colocando a literal primeiro:

String comando = null;

if ("sair".equals(comando)) {
  System.out.println("Encerrando o programa.");
}

Como "sair" é uma literal, ela nunca é null, então o método equals() sempre pode ser chamado com segurança, não importa o que comando contenha. Se comando for null, o resultado é simplesmente false, sem lançar exceção nenhuma.

Repare que essa técnica não trata um erro que aconteceu: ela reorganiza a comparação de um jeito que o erro simplesmente não tem como ocorrer, tornando a checagem manual de null desnecessária nesse caso específico.

Essa inversão é conhecida como notação Yoda (Yoda notation ou Yoda conditions), numa referência ao jeito peculiar como o personagem Yoda, de Star Wars, organiza as palavras nas frases. É uma técnica opcional, mas vale a pena conhecer: você provavelmente vai encontrá-la em código de terceiros, e pode adotá-la nos seus próprios comandos if sempre que houver risco de comparar algo que pode ser null.

Como substituir caracteres ou substrings em uma String

O método replace() substitui caracteres ou trechos inteiros de uma string:

public class Main {
  public static void main(String[] args) {
      String frase = "Java é uma linguagem difícil de aprender";

      String fraseCorrigida = frase.replace("difícil", "acessível");

      System.out.println(fraseCorrigida); // Java é uma linguagem acessível de aprender
  }
}

Como verificar se uma String contém uma substring

public class Main {
  public static void main(String[] args) {
      String frase = "Aprendendo Java do zero";

      if (frase.contains("Java")) {
          System.out.println("A frase contém a palavra Java.");
      } else {
          System.out.println("A frase não contém a palavra Java.");
      }
  }
}

Esses foram alguns dos métodos mais usados de String. Existem muitos outros na documentação oficial, e vale a pena explorá-la conforme surgirem necessidades específicas.

O que vem a seguir

Neste quinto artigo, conhecemos String em profundidade: como criar, formatar, medir, dividir, juntar, converter, comparar, substituir trechos e verificar a presença de uma substring dentro de outra.

Na Parte 6 desta série, vamos ver como programas Java recebem dados do usuário e devolvem resultados, com o tópico "Quais são as formas de entrada e saída de dados".

Até lá!

Este artigo é parte de uma série de introdução a Java escrita do zero, com progressão didática própria pensada para quem nunca programou na linguagem antes.

Artigos dessa série na DIO: