Strings em Java: criar, concatenar e usar métodos de String

O que é uma String

Uma String contém uma sequência de caracteres - texto como um nome, uma frase ou uma linha lida de um arquivo. Você viu String listada entre os tipos por referência na página anterior; aqui você vai trabalhar de fato com uma. Você escreve um literal de string com aspas duplas (aspas simples são reservadas para um único char):

public class Main {
    public static void main(String[] args) {
        String greeting = "Hello, world";
        String empty = "";
        String name = "Ada";

        System.out.println(greeting);
        System.out.println("Name has " + name.length() + " characters");
    }
}

name.length() retorna a quantidade de caracteres - 3 para "Ada". É uma chamada de método, então precisa dos parênteses.

Juntando strings

O operador + cola strings umas nas outras. Se qualquer um dos lados de + for uma string, o outro lado é convertido em texto automaticamente, então você pode misturar números e booleanos sem nenhum trabalho extra:

public class Main {
    public static void main(String[] args) {
        String first = "Ada";
        String last = "Lovelace";

        String full = first + " " + last;
        System.out.println(full);

        int age = 36;
        System.out.println(full + " is " + age + " years old");
    }
}

Um detalhe importante: como + é avaliado da esquerda para a direita, "" + 1 + 2 produz "12" (string + int, depois string + int), mas 1 + 2 + "" produz "3" (os dois inteiros são somados primeiro e depois viram texto). Na dúvida, coloque a aritmética entre parênteses.

Strings são imutáveis

Esta é a coisa mais importante a entender sobre strings em Java: uma String nunca muda depois de criada. Todo método que "modifica" uma string na verdade retorna uma string totalmente nova e deixa a original intacta. Então, se você esquecer de capturar o valor de retorno, nada acontece:

public class Main {
    public static void main(String[] args) {
        String s = "hello";

        s.toUpperCase();              // resultado descartado - bug!
        System.out.println(s);        // ainda "hello"

        s = s.toUpperCase();          // captura a nova string
        System.out.println(s);        // agora "HELLO"
    }
}

A primeira chamada calcula "HELLO" e o descarta imediatamente. Apenas a segunda linha, que atribui de volta a s, tem algum efeito visível. Quase todo mundo cai nessa uma vez.

Comparando strings

Use .equals() para comparar o conteúdo de duas strings. Recorrer a == é o erro clássico de iniciante: == pergunta "são o mesmo objeto na memória?", e não "elas contêm o mesmo texto?":

public class Main {
    public static void main(String[] args) {
        String a = "code";
        String b = new String("code");

        System.out.println(a == b);            // false - different objects
        System.out.println(a.equals(b));       // true  - same characters

        System.out.println("Hi".equalsIgnoreCase("hi"));  // true
    }
}

a == b é false aqui porque new String(...) força um objeto separado. Sempre compare valores de strings com .equals() (ou .equalsIgnoreCase() para ignorar maiúsculas e minúsculas). Um truque útil para evitar um erro quando um dos lados pode ser null é chamar .equals no literal: "yes".equals(input) nunca lança exceção, mesmo que input seja null.

Métodos de String do dia a dia

Como as strings são imutáveis, cada um destes retorna uma nova string (ou um valor) em vez de alterar a original. Estes são os que você vai usar o tempo todo:

public class Main {
    public static void main(String[] args) {
        String s = "  Coddy Java  ";

        System.out.println(s.trim());              // "Coddy Java"
        System.out.println(s.trim().toUpperCase()); // "CODDY JAVA"
        System.out.println(s.contains("Java"));    // true
        System.out.println(s.indexOf("Java"));     // 8
        System.out.println("Coddy".charAt(0));     // 'C'
        System.out.println("a,b,c".split(",").length); // 3
        System.out.println("hello".replace("l", "L")); // "heLLo"
    }
}

Repare no encadeamento: s.trim().toUpperCase() funciona porque trim() retorna uma string, na qual você então chama toUpperCase(). substring é outro recurso muito usado - ele recebe um índice inicial (inclusivo) e um índice final opcional (exclusivo):

public class Main {
    public static void main(String[] args) {
        String date = "2026-06-04";

        System.out.println(date.substring(0, 4));  // "2026"
        System.out.println(date.substring(5));     // "06-04"
    }
}

Os índices começam em zero, então substring(0, 4) pega os caracteres de 0 a 3. Pedir um índice além do fim lança uma StringIndexOutOfBoundsException.

Construindo strings em um laço

Concatenar com + é tranquilo para algumas poucas partes, mas fazer isso dentro de um laço grande é lento - cada + cria uma nova string e copia tudo. Quando você montar texto em um laço, use StringBuilder, que altera um buffer no lugar e produz a string final apenas uma vez no fim:

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);   // "1 2 3 4 5"
    }
}

append retorna o mesmo builder, então as chamadas se encadeiam. Chame .toString() para obter uma String comum no fim. Para junções pontuais, fique com +; para acumular muitas partes, StringBuilder é a ferramenta certa.

A seguir: Formatação de strings

A concatenação fica bagunçada assim que você precisa de colunas alinhadas, casas decimais fixas ou números com preenchimento. O String.format e o printf do Java usam um template com marcadores % para lidar com tudo isso de forma limpa - é o tema da próxima página.