Listas, vetores e cadeias de caracteres em Java

Um ArrayList armazena valores em ordem. Ele cresce quando você adiciona um elemento e diminui quando remove um. Cada elemento tem um índice, que começa em 0. Importe a classe antes de usá-la: import java.util.ArrayList;.

Crie uma lista com tipo definido

ArrayList<String> drinks = new ArrayList<>();
drinks.add("tea");
drinks.add("milk");

O tipo dentro de <String> indica o que a lista armazena. O diamante <> à direita permite que Java infira esse mesmo tipo. A lista começa vazia, com tamanho 0; após essas duas chamadas, contém [tea, milk] e tem tamanho 2. Imprimir a lista diretamente mostra seus elementos: System.out.println(drinks);.

O tipo dos elementos de uma lista deve ser um tipo de classe. Para números, use uma classe empacotadora: Integer para int, Double para double, Boolean para boolean ou Character para char. ArrayList<int> não compila. Com ArrayList<Integer> numbers = new ArrayList<>();, numbers.add(5) funciona porque Java empacota o int em um Integer. Lê-lo em int n = numbers.get(0); desempacota o valor.

Acompanhe cada mudança de índice

String old = drinks.set(0, "coffee");
drinks.add(1, "water");
String last = drinks.get(2);

set(0, "coffee") substitui o primeiro elemento e retorna o valor antigo, então old é "tea". O tamanho continua 2. Inserir "water" no índice 1 desloca "milk" para a direita. A lista agora é [coffee, water, milk]; last é "milk" e o tamanho é 3.

O índice adicional permitido para inserção é a posição logo após o último elemento atual. Nessa lista, add(3, "juice") acrescenta ao final, mas get(3) falharia antes dessa inserção. Um índice inválido causa uma IndexOutOfBoundsException. Use get(size() - 1) para o último elemento, depois de verificar que a lista não está vazia.

Comece com dados ou colete entradas

Com import java.util.List;, new ArrayList<>(List.of("red", "green", "blue")) cria uma lista modificável contendo esses valores. List.of(...) sozinho cria uma lista não modificável: add, set e remove lançam UnsupportedOperationException. Você também verá List<String> names = new ArrayList<>();; a variável do tipo geral List continua oferecendo esses métodos de lista.

Para coletar linhas até uma linha vazia, use um Scanner chamado scanner e uma lista vazia chamada lines:

while (true) {
    String line = scanner.nextLine();
    if (line.isEmpty()) {
        break;
    }
    lines.add(line);
}

A linha que encerra a entrada é verificada antes da adição, portanto não é armazenada. lines.size() conta as linhas armazenadas. lines.isEmpty() testa se não há nenhuma, e lines.clear() remove todas quando você precisa reutilizar a lista.

Remover um elemento altera tanto o tamanho quanto os índices dos elementos seguintes. Uma busca informa se um valor existe ou onde ele está agora. Mantenha clara a diferença entre um valor e sua posição, especialmente em uma lista de inteiros.

Dois significados de remove

Para [coffee, water, milk], remove(0) retorna "coffee" e deixa [water, milk]. O antigo índice 2 de "milk" agora é inválido; esse valor passou para o índice 1. Um índice guardado só é útil enquanto as alterações não mudarem as posições que ele descreve.

Remover por valor não significa remover todas as correspondências. Começando com [a, b, a], remove("a") deixa [b, a]. Uma segunda chamada remove o "a" restante. Remover um valor ausente retorna false e deixa a lista inalterada, então você pode usar o resultado diretamente:

boolean removed = names.remove("Lena");
if (removed) {
    System.out.println("Name removed");
}

A armadilha da sobrecarga com inteiros

Um argumento int seleciona a forma por índice, mesmo quando a lista armazena inteiros:

ArrayList<Integer> numbers = new ArrayList<>(List.of(10, 20, 30));
int removed = numbers.remove(1);
boolean found = numbers.remove(Integer.valueOf(10));

A primeira chamada remove o índice 1, então removed é 20 e a lista passa a ser [10, 30]. A segunda chamada fornece explicitamente um objeto Integer. Ela remove o valor 10, torna found verdadeiro e deixa [30]. Chamar remove(10) na lista original de três elementos tentaria acessar o índice 10 e lançaria IndexOutOfBoundsException.

Escolha um resultado de busca

Para colors = [red, green, blue, green], contains("green") é true, indexOf("green") é 1 e lastIndexOf("green") é 3. contains fornece uma resposta sim ou não. Os dois métodos de índice fornecem a primeira ou a última posição correspondente. Um valor ausente produz false ou -1, respectivamente.

Esses métodos usam equals para comparar elementos. O conteúdo das cadeias de caracteres deve ser exatamente igual, inclusive quanto a maiúsculas e minúsculas: indexOf("Green") é -1 nessa lista. Para uma busca sem essa distinção, um laço pode comparar cada nome com equalsIgnoreCase.

Uma correspondência no índice 0 continua sendo uma correspondência. O teste indexOf(x) > 0 deixa de encontrá-la. Se você precisa da posição, teste explicitamente o marcador de ausência:

int index = colors.indexOf("red");
if (index != -1) {
    colors.remove(index);
}

Aqui a busca retorna 0, o teste é satisfeito e remover o índice 0 deixa [green, blue, green]. Para evitar nomes duplicados, verifique antes de adicionar: if (!names.contains(name)) { names.add(name); }. Para remover todas as ocorrências, você pode repetir a remoção enquanto contains for verdadeiro ou usar um laço seguro em ordem inversa. Um laço em ordem direta que sempre incrementa após a remoção pode pular um elemento deslocado.

Uma variável de lista armazena uma referência a um objeto. Ela não armazena todos os elementos dentro da própria variável. Isso explica por que alterar uma lista por meio de um nome pode afetar outro nome e por que atribuir um valor a um parâmetro tem um efeito diferente de editar seus elementos.

Acompanhe as referências

ArrayList<String> original = new ArrayList<>(List.of("tea"));
ArrayList<String> alias = original;
ArrayList<String> copy = new ArrayList<>(original);
alias.add("milk");
copy.add("juice");

original e alias apontam para uma mesma lista. Após a adição por meio de alias, ambos mostram [tea, milk]. A cópia é uma lista separada, criada antes dessa adição, portanto contém [tea, juice]. Dois nomes para um objeto são apelidos de referência. A atribuição copia uma referência; o construtor de cópia cria uma nova lista e copia os elementos para ela.

A lista copiada contém referências aos mesmos objetos de elemento. Com cadeias de caracteres e valores empacotados, esses objetos não podem mudar, portanto substituir uma posição em uma lista não altera a posição da outra. Copiar uma lista é suficiente para que as duas adicionem, removam e substituam elementos independentemente.

Um método recebe uma cópia da referência

Java passa argumentos por valor. Para uma lista, esse valor é uma referência. A variável de quem chama o método e o parâmetro inicialmente apontam para a mesma lista:

static void addBonus(ArrayList<Integer> scores, int bonus) {
    for (int i = 0; i < scores.size(); i++) {
        scores.set(i, scores.get(i) + bonus);
    }
}

Chamar addBonus(scores, 5) em [70, 85] altera a lista de quem chamou o método para [75, 90]. O método não precisa retornar uma lista porque edita o objeto compartilhado. Mas atribuir scores = new ArrayList<>(); dentro do método apenas redireciona seu parâmetro local. A variável de quem chamou o método continua apontando para a lista antiga.

Um parâmetro int recebe uma cópia do número. Alterá-lo não pode mudar a variável int de quem chamou o método. Nos dois casos, o parâmetro é local; a diferença é se seu valor leva a um objeto modificável compartilhado.

Retorne novos dados quando essa for a tarefa

static ArrayList<String> longWords(ArrayList<String> words, int minLength) {
    ArrayList<String> result = new ArrayList<>();
    for (String word : words) {
        if (word.length() >= minLength) {
            result.add(word);
        }
    }
    return result;
}

O método lê words e escreve apenas em result, portanto a entrada permanece inalterada. Um método que altera um argumento deve comunicar esse comportamento, como addBonus faz. Um método que retorna novos dados facilita a verificação da saída separadamente da entrada.

Compare conteúdos e trate a ausência de resultados

a == b testa se duas referências de lista apontam para o mesmo objeto. a.equals(b) testa se os tamanhos são iguais e se os elementos são iguais e estão na mesma ordem. Duas listas [1, 2] construídas separadamente têm conteúdos iguais, mas identidades diferentes; [2, 1] não tem conteúdo igual na ordem da lista.

Uma lista vazia é um objeto real de tamanho 0. Um laço sobre ela é executado zero vezes, mas get(0) falha porque não há índices de elementos. null significa que não há objeto de lista; nesse caso, até size() lança NullPointerException. Um método sem correspondências pode retornar uma lista de resultado vazia, permitindo que quem o chama percorra o resultado normalmente.

Um vetor armazena uma quantidade fixa de elementos de um mesmo tipo. Você escolhe seu comprimento ao criá-lo. Os elementos podem mudar, mas o número de posições nesse vetor não. Vetores podem armazenar valores primitivos diretamente.

Crie e preencha posições

int[] scores = new int[5];
scores[0] = 90;
int first = scores[0];
int[] primes = {2, 3, 5, 7, 11};

new int[5] cria cinco posições. Seus índices são 0, 1, 2, 3 e 4. Colchetes permitem ler e escrever uma posição, então first passa a ser 90. O inicializador de primes cria e preenche cinco posições. Quando um vetor preenchido é necessário como expressão, por exemplo, como argumento de um método, use new int[] {2, 3, 5}.

O comprimento é um campo: scores.length, sem parênteses. Ele conta todas as posições, inclusive aquelas às quais você não atribuiu valores. Adicionar um valor à posição 0 não altera o comprimento de 5 para 1.

Esses nomes não são intercambiáveis. Um vetor não tem o método size(), e uma cadeia de caracteres precisa de parênteses após length.

Conheça os valores iniciais

Novas posições de vetores recebem valores padrão. Vetores de tipos numéricos primitivos começam com zero: 0 para int, 0,0 para double. Um boolean[] começa com false; um char[] começa com o caractere cujo código é zero, escrito '\u0000'. Vetores de tipos de classe, incluindo String[], começam com referências null.

String[] words = new String[3];
words[0] = "sun";
System.out.println(words[0].length());

Isso imprime 3 porque a posição 0 agora se refere a "sun". As posições 1 e 2 ainda contêm null. Chamar words[1].length() lança NullPointerException: ainda não há uma cadeia de caracteres nessa posição. Uma posição com o valor padrão null é diferente de uma cadeia de caracteres vazia "", que é um objeto de comprimento 0.

Leia a saída e mantenha-se dentro do vetor

Importe java.util.Arrays e use System.out.println(Arrays.toString(scores)); para imprimir [90, 0, 0, 0, 0]. Imprimir scores diretamente mostra um código de tipo e identidade como [I@1b6d3586, não seus elementos. O código de identidade não é uma apresentação útil dos números armazenados.

Para uma semana de temperaturas em graus Celsius:

double[] temps = {12.5, 14.0, 9.5, 11.0, 15.5, 13.0, 10.5};
temps[2] = 10.0;

A leitura do terceiro dia muda de 9,5 para 10,0. A primeira leitura é temps[0]; a última é temps[6], ou temps[temps.length - 1]. temps[7] está fora do vetor. Java lança ArrayIndexOutOfBoundsException para um índice de vetor inválido. Em um laço com índice, use i < temps.length: i <= temps.length tenta acessar uma posição extra após a última válida. Um vetor de comprimento zero não tem nenhum índice de elemento válido.

Uma variável de vetor armazena uma referência, assim como uma variável de lista. Atribuir essa referência cria outro nome para o mesmo vetor. Uma cópia separada precisa de um novo objeto de vetor, e comparar conteúdos exige um método que verifique as posições.

Atribuição e cópia

int[] a = {4, 9, 2};
int[] alias = a;
int[] copy = Arrays.copyOf(a, a.length);
alias[0] = 99;

Agora a e alias mostram [99, 9, 2]; copy ainda mostra [4, 9, 2]. Arrays.copyOf(a, a.length) cria um novo vetor do mesmo comprimento. a.clone() também pode copiá-lo. Importe java.util.Arrays para usar os métodos utilitários.

Um comprimento solicitado diferente altera o novo vetor, não o antigo. Arrays.copyOf(new int[] {2, 3, 5}, 4) resulta em [2, 3, 5, 0]. As posições extras recebem valores padrão. Para fazer uma variável se referir a um vetor maior, atribua a cópia retornada a essa variável. Qualquer apelido de referência do original continua se referindo ao vetor antigo.

Chamadas de método compartilham o objeto

static void doubleAll(int[] values) {
    for (int i = 0; i < values.length; i++) {
        values[i] = values[i] * 2;
    }
}

O parâmetro recebe uma cópia da referência. Portanto, o método altera as posições do vetor de quem o chamou. Reatribuir values a um novo vetor alteraria apenas o parâmetro. Um método também pode retornar um novo vetor: return new int[] {values[0], values[values.length - 1]}; produz [4, 2] para a entrada {4, 9, 2}. Essa expressão precisa de uma entrada não vazia porque lê dois índices.

A igualdade de conteúdo é diferente para vetores

Para vetores criados separadamente a = {1, 2} e b = {1, 2}, tanto a == b quanto a.equals(b) são falsos: equals de vetores verifica a identidade. Arrays.equals(a, b) é verdadeiro porque os elementos correspondentes são iguais. Isso difere de ArrayList, cujo equals compara conteúdos ordenados.

Guarde um valor antes de sobrescrevê-lo

Para trocar duas posições, mantenha um valor antigo em uma variável temporária:

int temp = a[0];
a[0] = a[2];
a[2] = temp;

Começando com {4, 9, 2}, a primeira linha guarda 4. A segunda produz [2, 9, 2]. A terceira restaura o 4 guardado no índice 2, completando [2, 9, 4]. Sem temp, atribuir a[2] = a[0] após a segunda linha copiaria 2 novamente e perderia o 4 original.

Escolha uma estrutura adequada aos dados

Vetores também aparecem em main(String[] args) e como resultado de String.split. Para um String[] words, new ArrayList<>(Arrays.asList(words)) cria uma lista que pode crescer. Para um int[], crie um ArrayList<Integer> e adicione cada inteiro em um laço. Arrays.asList aplicado ao vetor primitivo trata o vetor inteiro como um elemento, portanto não cria uma lista de seus números individuais.

Um laço permite que um trecho de código processe cada elemento. A escolha depende do que o corpo precisa: apenas um valor, sua posição ou uma forma de escrever de volta na coleção. Tanto vetores quanto ArrayLists permitem laços com índice e laços for-each.

Visite valores em ordem

for (String task : tasks) {
    System.out.println(task);
}

Leia isso como “para cada tarefa em tasks”. Com [shop, cook, clean], ele imprime as três cadeias de caracteres nessa ordem. A variável do laço tem o tipo dos elementos. Para ArrayList<Integer>, use int para desempacotar cada valor ou Integer para manter a referência ao objeto empacotador. Para caracteres de uma cadeia, for (char c : word.toCharArray()) visita os valores char.

Um laço for-each não fornece um índice. Se você precisa de linhas numeradas, use um laço com índice:

for (int i = 0; i < tasks.size(); i++) {
    System.out.println((i + 1) + ". " + tasks.get(i));
}

O índice começa em 0, mas o número de linha exibido começa em 1. Os parênteses fazem de i + 1 uma adição antes de se tornar parte do texto. Para um vetor, altere a condição para i < tasks.length e leia tasks[i]. Um laço while pode fazer o mesmo trabalho inicializando um contador antes do laço e incrementando-o no corpo.

Escreva de volta por meio de uma posição

int[] nums = {4, 9, 2};
for (int n : nums) {
    n = n * 2;
}

Isso deixa o vetor inalterado. Cada passagem coloca uma cópia de um valor primitivo em n; atribuir um valor a essa variável local não escreve na posição original. Para alterar o vetor:

for (int i = 0; i < nums.length; i++) {
    nums[i] = nums[i] * 2;
}

O resultado é [8, 18, 4]. Para uma lista de inteiros, a atualização correspondente é list.set(i, list.get(i) * 2). O índice indica a Java qual elemento armazenado deve ser substituído.

Ajuste os limites ao corpo

Para percorrer uma lista em ordem inversa, comece em tasks.size() - 1, continue enquanto i >= 0 e use i--. Isso visita clean, cook e depois shop. Para pegar elementos alternados, pode-se usar i += 2 em um laço em ordem direta.

Comparações entre vizinhos precisam de um intervalo menor. Se o corpo lê tanto list.get(i) quanto list.get(i + 1), a condição é i < list.size() - 1. A última posição inicial válida é o penúltimo elemento. Usar a condição habitual de percurso completo tentaria ler um vizinho inexistente após o último elemento.

Ao processar duas listas de mesmo comprimento juntas, use um índice para acessar ambas. Por exemplo, names.get(i) e scores.get(i) descrevem as entradas correspondentes. Um laço for-each é mais simples quando a posição não tem importância, como ao imprimir cada nome ou adicionar cada valor a um total.

Começar em 1 pula silenciosamente o primeiro elemento. Usar <= size() ou <= length tenta acessar um índice extra inválido. Uma lista ou vetor vazio não precisa de uma regra especial de percurso: a condição inicial é falsa, então o corpo é executado zero vezes. Qualquer código posterior que divida pela contagem ou leia um elemento deve tratar esse caso vazio.

Um acumulador mantém um resultado construído ao longo das passagens do laço. Inicialize-o antes do laço, atualize-o dentro dele e use-o depois. O valor inicial depende da tarefa: uma soma ou contagem começa em 0, enquanto um máximo precisa de um elemento real.

Totais e médias

int sum = 0;
for (int value : numbers) {
    sum += value;
}
if (!numbers.isEmpty()) {
    double average = (double) sum / numbers.size();
    System.out.println(average);
}

Para [4, 7, 8], sum muda de 0 para 4, depois 11 e depois 19. Ambos os operandos em sum / numbers.size() seriam inteiros, resultando em 6. Converter sum explicitamente antes da divisão resulta em aproximadamente 6,33. Converter o quociente já calculado apenas transformaria o 6 truncado em 6,0.

Uma coleção vazia não tem uma média comum. A divisão inteira por zero lança ArithmeticException; a divisão em ponto flutuante 0.0 / 0 resulta em NaN. Decida o que o caso vazio significa para o programa antes de dividir, por exemplo, exibindo “Nenhuma medição”. Para as distâncias decimais [5.0, 7.5, 10.0] km, um total double é 22,5 km e a média é 7,5 km.

Conte apenas as correspondências

Uma contagem condicional começa em 0 e só é incrementada quando seu teste é satisfeito. Para as temperaturas {22, 27, 31, 24, 26} em graus Celsius, if (t > 25) { count++; } produz 3. Coloque a inicialização fora do laço; redefinir count a cada passagem descartaria as correspondências anteriores.

Encontre um valor extremo e sua posição

Para um vetor não vazio, comece com int max = values[0];. Substitua max sempre que um valor visitado for maior. Começar em 0 falha em {-5, -2, -9}: informa 0, embora nenhum elemento tenha esse valor. Começar com -5 permite que o laço chegue ao máximo correto, -2. Um mínimo usa o mesmo padrão com <.

Quando a posição importa, mantenha o índice do melhor valor:

int best = 0;
for (int i = 1; i < numbers.size(); i++) {
    if (numbers.get(i) > numbers.get(best)) {
        best = i;
    }
}

Para [4, 7, 8], best termina em 2, e numbers.get(best) é 8. O laço começa em 1 porque o índice 0 já é o candidato inicial. Com >, um valor igual não substitui o candidato atual, preservando o primeiro máximo. Com >=, cada empate o substitui, preservando o último máximo. Verifique se a coleção está vazia antes de criar um candidato no índice 0.

Colete valores correspondentes

A filtragem usa uma lista de resultado vazia como acumulador. Visite cada palavra, adicione-a quando word.length() > 4 e retorne o resultado. Para [sun, planet, moon, galaxy], o resultado é [planet, galaxy]. Ler a entrada e adicionar a uma lista separada deixa a entrada inalterada.

Para dois elementos Integer, == compara a identidade dos objetos. Valores pequenos mantidos em cache podem ocultar esse erro; valores maiores iguais podem ser objetos diferentes. Compare com equals ou desempacote primeiro em variáveis int. Os operadores numéricos <, >, <= e >= desempacotam valores empacotados, então o código do melhor índice compara seus números.

Uma busca sequencial verifica os elementos em sequência. Ela funciona com dados em qualquer ordem. Uma busca bem-sucedida pela primeira correspondência pode parar antes; uma busca sem sucesso deve chegar ao fim para saber que nenhum elemento corresponde.

Retorne o primeiro índice correspondente

static int indexOfName(ArrayList<String> names, String target) {
    for (int i = 0; i < names.size(); i++) {
        if (names.get(i).equals(target)) {
            return i;
        }
    }
    return -1;
}

Se o primeiro nome correspondente estiver no índice 2, o método verifica os índices 0, 1 e 2 e retorna 2 imediatamente. O return -1 fica após o laço porque somente um percurso concluído estabelece que a busca falhou. Colocar else { return -1; } dentro dele faria o método parar no primeiro elemento que não correspondesse e ignorar todos os candidatos seguintes.

O marcador de ausência -1 não pode ser um índice válido. Quem chama o método deve verificá-lo antes de ler o resultado:

int index = indexOfName(names, "Ahmed");
if (index != -1) {
    System.out.println(names.get(index));
}

O teste index > 0 deixaria passar uma correspondência válida no índice 0. Usar -1 diretamente em get lançaria uma exceção. Em uma lista vazia, o corpo do laço nunca é executado, e o método retorna -1 corretamente.

Ajuste a comparação à tarefa

Para valores exatos em listas, contains e indexOf já fazem uma busca sequencial. Escreva um laço para um vetor ou uma condição como “começa com L”. Use equals ou equalsIgnoreCase para cadeias de caracteres, == para valores primitivos e equals para dois objetos Integer. Um teste de identidade de cadeias de caracteres pode deixar passar textos iguais.

Para String[] cities = {"Oslo", "Lima", "Lagos", "Pune"}, teste cities[i].startsWith("L"). O índice 0 falha; o índice 1 é aceito, então o resultado da primeira correspondência é 1. Se a tarefa pedir todas as correspondências, não retorne nesse ponto. Acrescente os índices correspondentes a uma lista de resultados e termine o percurso; isso resulta em [1, 2]. Para contar correspondências, incremente um contador em vez de armazenar posições.

Escolha a forma da resposta

Uma busca com resposta sim ou não pode começar com boolean found = false;. Ao encontrar uma correspondência, defina-a como verdadeira e use break para sair do laço. Sem o break, a resposta final continua verdadeira, mas o programa verifica valores de que não precisa mais. Um método de busca também pode retornar true imediatamente e retornar false após o laço.

Retornar um elemento exige um resultado separado para “nada encontrado”. Para uma String, isso costuma ser null; quem chama o método deve verificá-lo antes de chamar um método de String. Retornar um índice com -1 torna o caso de ausência visível sem afirmar que uma cadeia de caracteres vazia é um dado ausente.

Conte o trabalho que a busca realmente faz

Um alvo na primeira posição exige uma comparação. Um alvo na terceira posição exige três. Um alvo ausente em 10.000 nomes exige todas as 10.000 comparações. A primeira comparação sem correspondência não pode estabelecer que o alvo está ausente das posições restantes. Uma busca por todas as correspondências também verifica cada elemento, mesmo após uma correspondência inicial, porque valores posteriores também podem corresponder.

Remover elementos de um ArrayList altera as posições que um laço tenta visitar. O padrão seguro depende de você precisar alterar a lista original ou construir um resultado separado. Substituir valores é mais simples porque mantém as posições no lugar.

Veja como um laço em ordem direta pula um valor

Suponha que um laço remova números pares de [3, 8, 8, 5] e sempre incremente i. No índice 1, ele remove o primeiro 8. O segundo 8 passa para o índice 1, mas a próxima passagem usa o índice 2. O resultado é [3, 8, 5], com um número par restante. A condição estava correta; o problema foi o deslocamento após a remoção.

Um laço for-each sobre um ArrayList também não deve adicionar ou remover elementos por meio da lista. Ele usa um iterador cujo estado de percurso deixa de corresponder à lista alterada. Java geralmente informa uma ConcurrentModificationException. Algumas alterações podem, em vez disso, encerrar o laço silenciosamente, deixando um elemento sem ser visitado. A ausência de uma exceção não torna essa alteração segura.

Remova em ordem inversa para manter estáveis as posições não verificadas

for (int i = numbers.size() - 1; i >= 0; i--) {
    if (numbers.get(i) % 2 == 0) {
        numbers.remove(i);
    }
}

Para [3, 8, 8, 5], o índice 3 contém 5 e é mantido. O índice 2 contém 8 e é removido. O índice 1 ainda contém o outro 8 e é removido em seguida. O índice 0 contém 3 e é mantido. O resultado é [3, 5]. Uma remoção desloca os elementos à direita do índice atual, que esse laço em ordem inversa já verificou.

Construa a lista dos valores a manter

Quando a lista original deve permanecer inalterada, crie uma nova lista:

ArrayList<Integer> odds = new ArrayList<>();
for (int value : numbers) {
    if (value % 2 != 0) {
        odds.add(value);
    }
}

Esse laço for-each é seguro porque lê numbers e adiciona elementos a outra lista. Com [3, 8, 8, 5] como entrada, odds contém [3, 5] e a entrada ainda contém os quatro valores. Um vetor também não pode diminuir; filtrar seus valores também exige um novo vetor ou uma lista.

Deixe um iterador gerenciar sua própria remoção

Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    if (it.next() % 2 == 0) {
        it.remove();
    }
}

Importe java.util.Iterator. next() fornece o próximo elemento, e it.remove() remove o elemento recém-retornado, mantendo consistente a posição do iterador. Não substitua essa chamada por numbers.remove(...) nesse laço.

Um laço while em ordem direta também pode funcionar se incrementar apenas quando nada for removido. Após a remoção, ele deve examinar novamente o mesmo índice, onde chegou o próximo elemento. Isso exige mais cuidado do que um laço em ordem inversa ou uma nova lista de resultado.

Substituições e adições têm efeitos diferentes

set(i, value) é seguro em um laço com índice porque não altera o tamanho nem as posições. Adicionar em cada passagem enquanto se testa i < list.size() pode continuar afastando o final indefinidamente. Guarde int originalSize = list.size(); e percorra somente até esse limite quando cada elemento original deve causar o acréscimo de um valor.

Uma String armazena texto como uma sequência de valores char. Os índices começam em 0, assim como em vetores e listas. Um objeto String não pode mudar após a criação, portanto métodos que produzem texto alterado retornam um resultado que você precisa guardar.

Um caractere é diferente de uma cadeia de caracteres

"Hello".length() é 5. "Hello".charAt(0) é 'H' e charAt(4) é 'o'. Um char usa aspas simples e contém uma unidade de código UTF-16; uma String usa aspas duplas e pode conter zero, uma ou muitas dessas unidades. "Java".charAt(0) == 'J' compara dois caracteres primitivos. Comparar esse char com "J" não compila porque os tipos são diferentes.

charAt(length()) ultrapassa o fim e lança StringIndexOutOfBoundsException. Até charAt(0) falha para "". Verifique isEmpty() antes de ler o primeiro caractere da entrada.

length() conta valores char de UTF-16, que nem sempre são símbolos exibidos completos. "café".length() é 4; "Hi 👋".length() é 5 porque o emoji de mão acenando ocupa duas posições char. Use essa contagem ao raciocinar sobre os índices desses métodos.

Visite e teste os caracteres

String text = "Programming in Java".toLowerCase();
int vowels = 0;
for (int i = 0; i < text.length(); i++) {
    char c = text.charAt(i);
    if ("aeiou".indexOf(c) >= 0) {
        vowels++;
    }
}

A conversão para minúsculas permite que o mesmo teste de pertinência reconheça vogais maiúsculas e minúsculas. Cada indexOf(c) é não negativo quando o caractere aparece em "aeiou". A contagem chega a 6: o, a, i, i, a, a. for (char c : text.toCharArray()) pode visitar os mesmos valores sem um índice.

A classe Character fornece testes como isLetter, isDigit, isWhitespace e isUpperCase. Character.isDigit('7') é verdadeiro, enquanto Character.isLetter('7') é falso. Character.toUpperCase(c) e toLowerCase(c) retornam valores char convertidos.

Caracteres também têm códigos numéricos. 'a' + 1 produz o int 98; (char) ('a' + 1) converte esse código em 'b'. Para um caractere de algarismo ASCII, subtrair '0' fornece seu valor: '7' - '0' é 7. Subtrair o código de zero funciona porque os códigos desses algarismos são consecutivos.

Leia a concatenação da esquerda para a direita

Quando o lado esquerdo de + é texto, o próximo número é unido como texto. Os parênteses forçam a adição numérica antes da junção. Algumas junções em uma expressão são um uso claro de +.

Guarde o texto retornado

String name = "Lena";
name.toUpperCase();
System.out.println(name);
name = name.toUpperCase();

A impressão ainda mostra "Lena": a chamada descartada não alterou seu objeto. A atribuição faz então name se referir a "LENA". A imutabilidade de String significa que o texto antigo permanece inalterado mesmo que outras variáveis se refiram a ele. Guardar o resultado e alterar o objeto original são operações diferentes.

O processamento de texto frequentemente segue uma sequência curta: encontrar um marcador, verificar se ele existe e extrair o trecho necessário. Operações de limpeza podem preparar o texto antes de uma busca ou comparação. Cada operação de String retorna um resultado sem alterar seu objeto original.

Encontre posições ou faça uma pergunta de sim ou não

Para "banana", indexOf('a') retorna 1, indexOf("a", 2) retorna 3 e lastIndexOf('a') retorna 5. O segundo argumento escolhe onde começa a busca em ordem direta. Uma busca sem correspondência retorna -1, como em indexOf("x").

Use contains(text) quando você só precisa saber se um texto aparece. startsWith(prefix) verifica o início e endsWith(suffix), o fim. "report.pdf".endsWith(".pdf") é verdadeiro. Essas buscas distinguem maiúsculas de minúsculas: "Hello".contains("hello") é falso. Os métodos de índice aceitam um char ou uma String; contains recebe texto.

Substring termina imediatamente antes do índice final

String word = "programming";
String middle = word.substring(3, 7);
String tail = word.substring(3);

middle é "gram", usando as posições 3, 4, 5 e 6. Seu comprimento é 7 - 3, ou 4. tail é "gramming", porque omitir o argumento final faz a extração ir até o fim da cadeia de caracteres. O início deve ser não negativo e não pode ser maior que o fim; o fim não pode ultrapassar length(). Limites inválidos lançam StringIndexOutOfBoundsException.

Para um endereço de e-mail, encontre o separador antes de extrair os trechos:

String email = "lena.ito@example.com";
int at = email.indexOf("@");
if (at != -1) {
    String user = email.substring(0, at);
    String domain = email.substring(at + 1);
}

O separador está no índice 8. O primeiro trecho termina antes dele, resultando em "lena.ito"; o segundo começa depois dele, resultando em "example.com". Se o marcador estiver ausente, at é -1. Chamar substring(0, at) sem a verificação falharia. Começar o segundo trecho em at manteria o @ no domínio.

Limpe apenas o que a operação visa

" hello ".trim() resulta em "hello"; os espaços internos permanecem. strip() trata outros caracteres de espaço em branco do Unicode, como o espaço eme. Ele usa a definição de espaço em branco de Java, que não inclui todos os caracteres que parecem espaços. "banana".replace('a', 'o') resulta em "bonono". "ab".repeat(3) resulta em "ababab".

Vazio e em branco são diferentes

isEmpty() testa se o comprimento é 0. isBlank() também aceita texto composto apenas de caracteres de espaço em branco de Java. Para " ", o primeiro é falso e o segundo é verdadeiro. Use o teste que corresponde à regra de entrada. Para limpar uma resposta como " Yes ", answer.trim().toLowerCase() retorna "yes". Armazene esse texto retornado se a variável deve guardar o valor limpo; uma chamada isolada answer.trim(); o descarta.

Uma linha de dados pode conter vários valores separados por uma vírgula ou outro marcador. A divisão produz um vetor de cadeias de caracteres; a análise e conversão de texto (parsing) transforma então campos selecionados em números. Verifique a estrutura dos dados antes de usar suas posições.

Divida em um vetor

String[] fields = "Ada,36,London".split(",");

Há três campos: "Ada", "36" e "London". As vírgulas não são mantidas. fields.length é 3, e fields[1] ainda é texto, não um número.

O separador passado a split é uma expressão regular, um padrão que nem sempre é texto literal. Uma vírgula representa a si mesma, mas ., |, *, + e ? têm significados especiais. Para dividir uma cadeia de versão em pontos literais, use "1.5.2".split("\\."). Duas barras invertidas na string Java produzem a única barra invertida do padrão que torna o ponto literal. split("."), por sua vez, corresponde a caracteres individuais e produz um vetor vazio nesse exemplo.

Trate espaços e partes vazias

Dividir "a b" em " " produz três partes: "a", "" e "b". Cada separador é um espaço, então espaços adjacentes deixam uma parte vazia entre eles. Para sequências de caracteres de espaço em branco, use:

String[] words = "  red   green blue ".trim().split("\\s+");

O resultado é [red, green, blue]. Usar trim antes evita uma parte inicial vazia causada por um separador no início. Por padrão, split descarta partes vazias no final: "a,b,,".split(",") produz apenas "a" e "b". Conte os campos realmente resultantes antes de acessá-los por índice.

Converta cada campo para o tipo desejado

Integer.parseInt("42") retorna o int primitivo 42. Integer.valueOf("-7") retorna um objeto Integer. Double.parseDouble("5.2") retorna 5,2, usando um ponto como separador decimal independentemente da configuração regional do computador. A conversão de inteiros aceita texto inteiro sem separador decimal. Integer.parseInt("4.5") falha em vez de arredondar.

Use trim nos campos antes da conversão, especialmente em texto inteiro: Integer.parseInt(" 42") lança NumberFormatException. Dividir em vírgulas não remove espaços ao redor dos campos. Uma contagem correta de campos também não garante que um campo contenha um número válido.

Leia um registro completo

String line = "Amira,10.5,63";
String[] parts = line.split(",");
if (parts.length == 3) {
    String name = parts[0].trim();
    double distanceKm = Double.parseDouble(parts[1].trim());
    int minutes = Integer.parseInt(parts[2].trim());
    double pace = minutes / distanceKm;
    System.out.println(name + ": " + pace + " min/km");
}

A distância é 10,5 km, o tempo é 63 minutos e o ritmo é 6,0 min/km. A linha incompleta "Amira,10.5" tem apenas dois campos; sem a verificação da contagem, parts[2] lançaria ArrayIndexOutOfBoundsException. Um programa pode pular ou informar esse registro incompleto antes de usar qualquer posição ausente.

Converta ou una texto novamente

String.valueOf(42) e Integer.toString(42) resultam em "42". String.join(", ", List.of("Oslo", "Lima", "Pune")) resulta em "Oslo, Lima, Pune", inserindo separadores apenas entre as partes. Ele aceita uma lista, um vetor ou argumentos separados de cadeias de caracteres. A junção não converte nem calcula: ela combina as cadeias de caracteres fornecidas.

Duas variáveis podem conter texto com os mesmos caracteres sem se referir ao mesmo objeto String. Escolha uma comparação com base na pergunta: conteúdos iguais, conteúdos iguais sem distinção entre maiúsculas e minúsculas ou qual texto vem primeiro na ordenação de Java.

Use equals para conteúdos

String answer = new String("yes");
System.out.println(answer == "yes");
System.out.println(answer.equals("yes"));

O primeiro resultado é falso: o objeto criado separadamente não é o objeto do literal. O segundo é verdadeiro porque os caracteres correspondem. Literais idênticos, como em "yes" == "yes", compartilham um objeto e podem fazer a comparação de identidade parecer confiável. Texto obtido em tempo de execução pode usar objetos novos ou existentes, então a identidade não é o teste para verificar uma entrada correspondente.

equalsIgnoreCase ignora a diferença entre maiúsculas e minúsculas: "YES".equalsIgnoreCase("yes") é verdadeiro. Ele não remove espaços. Para aceitar também espaços ao redor, limpe a entrada antes de comparar.

Para uma variável que pode ser null, chame o método a partir de um literal conhecido que não seja nulo: "yes".equals(answer) retorna falso para null. answer.equals("yes") lança NullPointerException se answer for null, pois nenhum objeto recebe a chamada.

Um laço de comando pode testar !command.equals("quit"). O ! nega a igualdade de conteúdo. command != "quit" testa referências e pode manter um laço em execução mesmo quando os caracteres digitados são “quit”.

Interprete o sinal de compareTo

a.compareTo(b) compara valores char de UTF-16 em sequência. Retorna um número negativo se a vier antes de b, zero se forem iguais e um número positivo se vier depois. Apenas o sinal importa para a ordenação; o resultado não precisa ser exatamente -1 ou 1.

Números armazenados como texto, portanto, não seguem a ordem numérica. Converta-os quando a tarefa for numérica. Letras maiúsculas sem acento do inglês precedem as minúsculas sem acento, então "Zebra" vem antes de "apple". O nome acentuado "Émile" vem depois de "Zoe" nessa ordenação. compareToIgnoreCase ignora maiúsculas e minúsculas; a ordem de dicionário específica de um idioma exige java.text.Collator.

Reutilize o padrão de mínimo para nomes

Para uma lista não vazia [Mia, Ahmed, Lucia]:

String first = names.get(0);
for (String name : names) {
    if (name.compareTo(first) < 0) {
        first = name;
    }
}

"Mia" começa como candidato. "Ahmed" vem antes na comparação e se torna o candidato; "Lucia" não o substitui. O resultado é "Ahmed". Verifique se a lista está vazia antes de ler seu primeiro elemento.

Um char individual é primitivo, então word.charAt(0) == 'A' é uma comparação correta de caracteres quando se sabe que a palavra não está vazia. O problema com == diz respeito à identidade de objetos, não a toda comparação que envolve texto.

Um StringBuilder contém texto modificável. Ele é útil quando um laço adiciona muitas partes ou quando caracteres precisam ser editados no próprio objeto. Algumas junções em uma expressão ficam claras com +, mas reconstruir repetidamente uma String crescente pode copiar seu conteúdo acumulado muitas vezes.

Acrescente partes e finalize com uma String

StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        sb.append(", ");
    }
    sb.append(i);
}
String result = sb.toString();

Não é necessária importação. append acrescenta cadeias de caracteres, chars, números ou booleanos ao final. A primeira passagem adiciona apenas 1; a segunda adiciona ", " e depois 2. O resultado é "1, 2, 3, 4, 5". Colocar um separador após cada número deixaria um separador indesejado no final. Para uma lista existente de cadeias de caracteres, String.join(", ", list) trata os separadores diretamente.

Repetir text += piece em um laço forma novos resultados String imutáveis. O prefixo acumulado precisa ser incluído a cada vez, então a quantidade copiada pode crescer quadraticamente conforme um resultado longo cresce. Um construtor de texto mantém um buffer modificável e acrescenta conteúdo a ele sem reconstruir todo o prefixo a cada passagem.

Edite posições e intervalos

length() e charAt(i) leem o construtor de texto como leem uma String. Os índices descrevem seu estado atual; uma inserção ou exclusão pode alterar posições posteriores.

Comece com new StringBuilder("Jva"). insert(1, 'a') produz "Java"; setCharAt(0, 'j') resulta então em "java". Para "2026-10-22", delete(4, 7) remove as posições 4, 5 e 6, deixando "2026-22". Substituir as posições 7 até 9 em "I like tea" por "coffee" resulta em "I like coffee".

Encadeie apenas métodos que retornam o construtor de texto

new StringBuilder().append("a").append(1).append('b').toString() resulta em "a1b". As chamadas de append retornam o mesmo construtor de texto, permitindo outra chamada. Os métodos de edição apresentados aqui também retornam o construtor, exceto setCharAt, que retorna void e precisa de uma instrução separada.

reverse() altera o objeto receptor. Se sb contiver "stressed", então String r = sb.reverse().toString(); deixa tanto r quanto o texto do construtor como "desserts". Para preservar o construtor original, inverta um novo construtor criado a partir de seu texto.

Compare os conteúdos finais

Para verificar um palíndromo, acrescente a forma minúscula de cada letra em "Was it a car or a cat I saw". O texto limpo é "wasitacaroracatisaw". Inverta um novo construtor que contenha esse texto, converta-o em uma String e compare com clean.equals(reversed). A comparação é verdadeira.

StringBuilder não sobrescreve equals para comparar conteúdos. Construtores separados que contêm "abc" não são iguais por esse método, e um construtor não é igual a uma String. Converta primeiro: sb1.toString().equals(sb2.toString()) compara o texto real.