Objetos, referências e igualdade em Java

Uma variável Java armazena um valor. A questão importante é se esse valor é um dado comum ou uma referência que aponta para um objeto. A atribuição copia esse valor nos dois casos.

Dados primitivos e referências a objetos

Java tem oito tipos primitivos: byte, short, int, long, float, double, char e boolean. Uma variável de tipo primitivo armazena seu dado diretamente. Uma variável de referência armazena uma referência a um objeto ou o valor especial null. Classes como String, Scanner e ArrayList, suas próprias classes e vetores são tipos de referência.

Em new Counter(), Java cria um objeto, executa seu construtor e produz uma referência. A atribuição armazena essa referência em c. Desenhe a variável como uma caixa com uma seta que aponta para um objeto separado. Cada avaliação de new cria um objeto separado, mesmo quando os argumentos são iguais.

Copie o valor e acompanhe o resultado

Com tipos primitivos, alterar a variável copiada deixa a primeira variável inalterada:

int a = 5;
int b = a;
b = b + 1;

A última linha lê 5 de b, soma 1 e armazena 6 em b. O valor em a permanece 5.

Para um exemplo com referência, use esta pequena classe:

class Counter {
    private int value;

    Counter() { this.value = 0; }
    Counter(int value) { this.value = value; }
    void increase() { value++; }
    int value() { return value; }
}

Agora acompanhe estas instruções:

Counter first = new Counter();
Counter second = first;
second.increase();
System.out.println(first.value()); // 1

Apenas a primeira linha cria um contador. A segunda linha copia a referência, então a chamada de método altera o único contador que ambas as variáveis alcançam. Para criar um contador independente com os mesmos dados, escreva new Counter(first.value()). Copiar uma variável não chama um construtor.

Classes empacotadoras e strings imutáveis

Cada tipo primitivo tem uma classe empacotadora, como Integer, Double, Boolean ou Character. Variáveis de tipos empacotadores armazenam referências ou null. Java pode converter automaticamente entre um tipo primitivo e seu tipo empacotador; essas conversões são empacotamento automático e desempacotamento. Listas armazenam referências, então uma lista de inteiros é ArrayList<Integer>.

String também é um tipo de referência, mas seus objetos são imutáveis: seus caracteres não podem mudar após a criação.

String s = "java";
String t = s;
t = t.toUpperCase();

Aqui, s ainda se refere a “java” e t se refere a “JAVA”. A última linha atribui o resultado a t; ela não altera a cadeia de caracteres original compartilhada. Métodos de String podem reutilizar o objeto original quando nenhuma alteração é necessária.

Exibir um objeto usa seu método toString(). Sem uma sobrescrita, o resultado herdado tem uma forma como Counter@7e9e5f8a: nome da classe, @ e um código de dispersão hexadecimal. Defina toString() quando a saída exibida deva mostrar os dados do objeto.

Duas variáveis que se referem ao mesmo objeto são apelidos de referência. Um apelido oferece outro caminho até dados existentes. Para acompanhar um programa, mantenha as variáveis separadas dos objetos que elas alcançam.

A mutação altera dados; a reatribuição altera uma variável

Uma mutação altera o estado de um objeto, como seu peso armazenado. Uma reatribuição coloca um valor diferente em uma variável. Para uma variável de referência, isso muda sua seta.

Use uma caixa cujo peso é dado em quilogramas:

class Box {
    private double weight;
    Box(double weight) { this.weight = weight; }
    double getWeight() { return weight; }
    void setWeight(double weight) { this.weight = weight; }
}

Acompanhe esta sequência:

Box a = new Box(2);
Box b = a;
b.setWeight(5);
b = new Box(7);

1. Desenhe a variável a apontando para o objeto A, com peso 2.
2. Desenhe b apontando para esse mesmo objeto A. Ainda há uma caixa.
3. Altere o peso dentro do objeto A para 5. Ambos os caminhos agora chegam ao peso 5.
4. Crie o objeto B com peso 7 e redirecione apenas b para ele.

Ao final, a.getWeight() é 5 e b.getWeight() é 7. A quarta instrução não reinicia o objeto A nem move a para o objeto B.

A alcançabilidade controla o tempo de vida de um objeto

Um objeto está alcançável enquanto o programa em execução puder seguir alguma cadeia utilizável de referências até ele. Essa cadeia pode passar por uma variável, um campo de objeto ou um elemento de lista. Portanto, o desaparecimento de uma variável local não é suficiente para tornar um objeto inalcançável se uma lista ainda o armazenar.

Continue o rastreamento com a = null;. O objeto A, que pesa 5 kg, agora não tem nenhum caminho alcançável neste exemplo. Ele está disponível para coleta de lixo. Java recupera automaticamente a memória de objetos inalcançáveis, mas o coletor escolhe quando fazê-lo; a atribuição não garante coleta imediata. O objeto B permanece alcançável por meio de b.

Você não libera objetos Java manualmente. Quando um programa perde sua última referência utilizável a um objeto, também perde a capacidade de inspecionar ou alterar os dados desse objeto.

Encontre os apelidos ocultos

Apelidos surgem quando um objeto é adicionado a uma lista, passado a um método, retornado de um método ou armazenado no campo de outro objeto. Cada operação pode passar uma referência adiante. Antes de alterar um objeto recebido de outro lugar, identifique quais outros trechos de código ainda podem alcançá-lo.

Um erro comum começa com o pensamento: “Copiei a variável, então tenho minha própria caixa.” Use um objeto novo quando as alterações precisarem ser independentes. Para diagnosticar o erro, conte as criações de objetos separadamente das atribuições, identifique cada objeto uma vez e processe cada instrução em ordem. Não redesenhe um objeto só porque uma segunda variável agora aponta para ele.

O valor null significa que uma referência não aponta para nenhum objeto. Ele é útil para um resultado ausente, mas um programa deve tratar essa ausência antes de tentar usar um objeto.

Ausente é diferente de vazio

String text = ""; refere-se a uma cadeia de caracteres real de comprimento 0. String text = null; não se refere a nenhuma cadeia, então não há objeto no qual chamar length().

Um tipo primitivo não pode armazenar null: int x = null; não compila. Um tipo empacotador pode armazená-lo: Integer x = null; compila. Converter esse valor empacotado em um tipo primitivo com int y = x; lança uma NullPointerException, pois o desempacotamento precisa de um objeto empacotador.

Campos recebem valores padrão iniciais quando um objeto é criado. Campos de referência começam como null, campos numéricos como 0 e campos booleanos como false, até que a inicialização lhes atribua outros valores. Variáveis locais não têm valor padrão. Ler uma variável local antes de lhe atribuir um valor causa um erro de compilação, como “a variável pode não ter sido inicializada”.

Encontre a referência ausente

Chamar um método de instância por meio de null, acessar um campo de instância por meio dele ou ler o comprimento de um vetor por meio dele lança NullPointerException em tempo de execução. Por exemplo:

String name = null;
System.out.println(name.length());

Leia o número da linha da exceção e identifique qual referência nessa linha estava ausente. Mensagens explicativas são ativadas por padrão a partir do Java 15. Uma mensagem pode dizer Cannot invoke "SimpleDate.getYear()" because "this.birthday" is null. Nomes locais podem aparecer como marcadores, como <local4>, dependendo dos detalhes da compilação. Acompanhe o código de volta até o construtor, a atribuição ou a busca que deveria ter fornecido o objeto.

Exibir uma variável String cujo valor é null exibe “null”; concatená-la produz um texto como “Hi null”. Essas operações não precisam chamar um método de instância por meio dessa variável. Elas podem revelar dados ausentes antes que uma chamada de método posterior falhe.

Verifique antes de usar

O operador && usa avaliação de curto-circuito: ele avalia o lado direito apenas se o lado esquerdo for verdadeiro.

if (name != null && name.length() > 0) {
    System.out.println(name);
}

Quando name é null, o primeiro teste é falso e length() é ignorado. Inverter os dois testes elimina essa proteção: a chamada de método seria executada primeiro.

A cadeia de caracteres fixa é um objeto conhecido, então seu equals pode receber null e retornar falso. command.equals("quit") falha quando command é null. Da mesma forma, x.equals(null) não é uma maneira de verificar se x existe: ela já exige um objeto.

Faça da ausência uma decisão clara de projeto

Inicialize um campo de lista com new ArrayList<>() para que uma coleção vazia esteja disponível imediatamente. Se uma busca retornar null para “não encontrado”, documente esse resultado e verifique-o no local da chamada. Evite preencher todos os campos com objetos arbitrários apenas para silenciar uma exceção: forneça o objeto de que o programa precisa ou dê à ausência um significado claro que o código que chama o método trate.

Java passa todos os argumentos por valor. Um parâmetro é uma nova variável que recebe uma cópia do valor do argumento. Para um argumento que é um objeto, o valor copiado é uma referência.

Alterar o parâmetro ou alterar o objeto?

Um parâmetro de tipo primitivo tem seus próprios dados:

static void addTen(int n) {
    n = n + 10;
}

Se x for 5, chamar addTen(x) deixa x em 5. Apenas o parâmetro local n passa a ser 15.

Um parâmetro de referência pode alcançar o mesmo objeto que quem chamou o método. Suponha que Person.growOlder() aumente a idade armazenada:

static void celebrate(Person p) {
    p.growOlder();
}

static void replace(Person p) {
    p = new Person("Bo", 30);
}

Durante celebrate(ana), o parâmetro p e a variável ana são apelidos de referência. A idade alterada permanece visível depois. Durante replace(ana), atribuir um valor a p redireciona apenas esse parâmetro. A variável ana de quem chamou o método continua se referindo à pessoa original. Um método que troca dois parâmetros de referência tem a mesma limitação: ele troca suas próprias cópias, não as variáveis de quem o chamou.

Receba um objeto de outra classe

Um controle de entrada pode ler a altura de uma pessoa e manter sua própria contagem de verificações. Esta classe espera uma pessoa não nula com um método getHeight() que retorna centímetros:

class HeightGate {
    private int minHeight;
    private int checks;

    HeightGate(int minHeight) {
        this.minHeight = minHeight;
    }

    boolean allowIn(Person p) {
        checks++;
        return p.getHeight() >= minHeight;
    }

    int checks() { return checks; }
}

Para um controle configurado para 120 cm, verificar pessoas de 132 cm e 115 cm retorna verdadeiro e falso. O controle informa então 2 verificações. Ele lê a altura da pessoa por meio de um método público e altera seu próprio contador.

Receba outro objeto da mesma classe

Dentro de SimpleDate.before(SimpleDate other), this é a data que recebe a chamada e other é o argumento. Uma classe pode ler os campos privados de qualquer objeto dessa mesma classe.

Para os campos day, month e year, compare nesta ordem:

boolean before(SimpleDate other) {
    if (year != other.year) {
        return year < other.year;
    }
    if (month != other.month) {
        return month < other.month;
    }
    return day < other.day;
}

Para 14 de março de 2001 e 2 de novembro de 2001, os anos coincidem e o mês 3 é menor que o mês 11, então a primeira data é anterior. Datas iguais retornam falso porque nenhuma é anterior à outra.

Person.olderThan(other) pode delegar a birthday.before(other.birthday). A comparação de datas pertence à classe que contém os dados da data. Métodos que chamam métodos de instância em um parâmetro precisam de um argumento não nulo; verifique-o ou inclua essa exigência na documentação de uso do método.

Um método que retorna um objeto retorna uma referência. Seu tipo informa que tipo de objeto pode ser retornado, mas não informa se o objeto é novo, compartilhado ou ausente. A finalidade do método deve deixar essa escolha clara.

Crie um resultado

Um método fábrica fornece um objeto. Ele pode criar um ou reutilizar um existente. Aqui, cada chamada cria deliberadamente um tíquete separado:

class TicketMachine {
    private int nextNumber = 1;

    Ticket issue() {
        Ticket t = new Ticket(nextNumber);
        nextNumber++;
        return t;
    }
}

A máquina espera um construtor Ticket que armazene seu número. Três chamadas criam três tíquetes numerados 1, 2 e 3. Retornar uma variável local é seguro: sua referência é copiada para quem chamou o método, que pode manter o objeto alcançável depois que a variável local sai de escopo.

Um método de cópia promete um objeto independente. Na classe Counter:

Counter copy() {
    return new Counter(this.value);
}

Após Counter a = new Counter(4); Counter b = a.copy(); b.increase();, a.value() é 4 e b.value() é 5. Substituir a.copy() por a compartilharia o contador.

Um método também pode construir um objeto calculado. Para um Point com campos double x e y:

Point midpoint(Point other) {
    return new Point((x + other.x) / 2.0,
                     (y + other.y) / 2.0);
}

Os pontos (2, 4) e (6, 10) resultam em (4,0; 7,0). O método calcula cada coordenada e passa ambas a um novo ponto; nenhum dos pontos originais muda.

Retorne um objeto já armazenado

O findByName de um cadastro deve retornar a pessoa armazenada correspondente se quem chama o método precisar trabalhar com essa entrada. Criar new Person(name, 0) retornaria dados substitutos inventados e desvincularia alterações posteriores do cadastro.

Uma busca pode retornar null quando não há correspondência:

Person p = register.findByName("Lin");
if (p != null) {
    System.out.println(p);
} else {
    System.out.println("Not found");
}

Se p for a pessoa armazenada, alterações por meio de p também alteram a pessoa alcançada pelo cadastro. Uma instrução return não copia o objeto.

Mantenha o estado interno mutável sob controle

Suponha que Person.getBirthday() retorne seu campo SimpleDate e que essa data tenha métodos modificadores. Quem chama o método pode então alterar a data de nascimento da pessoa sem chamar um método de Person. Isso é uma exposição de estado mutável.

Para proteger o campo, retorne uma nova data construída a partir de seus valores:

SimpleDate getBirthday() {
    return new SimpleDate(birthday.getDay(),
                          birthday.getMonth(),
                          birthday.getYear());
}

Essa versão exige que um objeto de data de nascimento tenha sido inicializado. Outros projetos usam uma data imutável ou oferecem consultas específicas sem um método de acesso à data. Escolha o comportamento de cada método: find normalmente compartilha uma entrada armazenada, enquanto copy cria independência. O nome curto de um método de acesso, por si só, não garante proteção.

Composição constrói uma classe usando campos cujos tipos são outras classes. Ela expressa uma relação de posse: uma pessoa tem uma data de nascimento; um curso tem um professor. O objeto externo armazena uma referência ao objeto contido.

Crie e conecte os objetos

Um construtor pode receber uma data existente:

class Person {
    private String name;
    private SimpleDate birthday;

    Person(String name, SimpleDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    boolean olderThan(Person other) {
        return birthday.before(other.birthday);
    }

    public String toString() {
        return name + ", born " + birthday;
    }
}

Chamar new Person("Ana", new SimpleDate(14, 3, 2001)) primeiro cria uma data e depois fornece sua referência à pessoa. Outra opção é um construtor de pessoa receber dia, mês e ano e criar a data dentro de seu corpo. Com essa abordagem, quem chama o construtor não mantém uma referência à data recém-criada.

Delegue tarefas ao objeto contido

A chamada birthday.before(other.birthday) pede ao objeto de data que compare datas. Person não precisa repetir as comparações de ano, mês e dia. A concatenação em toString() também delega: Java chama o toString() do objeto de data de nascimento para obter seu texto.

Um objeto de data pode ajudar a calcular a idade. Comece com o ano atual menos o ano de nascimento. Depois, forme a data do aniversário deste ano e subtraia um se a data atual vier antes dela. Uma pessoa nascida em 14 de março de 2001 tem 24 anos em 1 de janeiro de 2026: a diferença entre os anos é 25, mas o aniversário ainda não chegou. Em 14 de março de 2026, o aniversário já chegou e a idade é 25. Manter a comparação de datas em SimpleDate evita reproduzir suas regras em cada método de pessoa.

Decida se o objeto interno é compartilhado

O construtor acima armazena seu argumento diretamente. Se duas pessoas receberem um SimpleDate mutável, ambos os campos de data de nascimento apontarão para a mesma data. Alterar essa data afeta as duas pessoas.

Um construtor defensivo pode copiar o dia, o mês e o ano da data recebida. Uma data imutável não tem métodos que alterem seu estado e mantém seus valores fixos; campos primitivos simples podem ser final. Copiar na entrada é importante mesmo que um método de acesso retorne uma cópia depois, pois quem chamou o construtor originalmente ainda pode ter o objeto recebido.

Trate conexões opcionais

Um Course pode ainda não ter professor. Se esse for um estado significativo, teacherName() pode verificar o campo e retornar “ainda sem professor”. Caso contrário, exija um professor na construção.

Em course.getTeacher().getName(), cada chamada de instância precisa de um objeto: um curso nulo falha em getTeacher(), e um professor nulo falha em getName(). Um método no curso pode manter essa verificação de ausência em um só lugar e evitar que todos os chamadores precisem conhecer a mesma cadeia.

Um ArrayList<Person> é um objeto cujos elementos armazenam referências a pessoas. A lista controla sua sequência de entradas; cada pessoa controla seus próprios campos. São tipos separados de alteração.

Adicione um objeto e alcance-o novamente

ArrayList<Person> people = new ArrayList<>();
people.add(ana);
people.get(0).growOlder();

Esse código precisa de import java.util.ArrayList; e de uma pessoa existente e não nula ana. add copia a referência. A chamada growOlder() alcança a mesma pessoa que ana, então a alteração da idade fica visível pelos dois caminhos. Aqui, a lista nunca cria uma segunda pessoa.

Você pode criar um objeto ao adicioná-lo: people.add(new Person("Lin", 1998));, usando um construtor de pessoa que aceita um nome e um ano de nascimento. A lista fornece então ao programa um caminho até essa nova pessoa por meio de get ou de um laço. Argumentos de tipo de listas devem ser tipos de referência, então use ArrayList<Integer> para números inteiros.

Calcule a partir de objetos e selecione um objeto

Suponha que uma lista armazene pacotes com pesos de 2,5 kg, 4,0 kg e 1,5 kg. Um laço soma o peso de cada pacote:

double total = 0;
for (Parcel p : parcels) {
    total += p.getWeight();
}

As somas acumuladas são 2,5, 6,5 e 8,0 kg. Selecionar o pacote mais pesado exige uma referência e uma comparação:

Parcel heaviest = parcels.get(0);
for (Parcel p : parcels) {
    if (p.getWeight() > heaviest.getWeight()) {
        heaviest = p;
    }
}

Essa seleção exige uma lista não vazia. O resultado é o objeto do pacote de 4,0 kg, então quem chama o método também pode usar seus outros métodos. Para uma lista vazia, decida qual será o resultado de ausência antes de ler o elemento 0.

Busque em todas as entradas

Uma busca por nome em uma classe que armazena people pode usar:

Person findByName(String name) {
    for (Person p : people) {
        if (p.getName().equals(name)) {
            return p;
        }
    }
    return null;
}

Essa versão espera pessoas não nulas com nomes não nulos. A primeira correspondência é retornada imediatamente. O return null final pertence ao trecho após o laço: uma comparação sem correspondência na primeira pessoa não exclui correspondências posteriores.

contains, indexOf e remove(Object) fazem buscas usando equals. Se Person herdar a igualdade baseada em identidade, uma pessoa recém-criada não corresponderá a uma existente só porque seus campos coincidem.

Remova uma entrada sem destruir um objeto

Um objeto pode aparecer duas vezes em uma lista ou em várias listas. Remover uma entrada não destrói o objeto nem remove outras referências a ele.

Não remova entradas diretamente da mesma lista durante um percurso for-each. Isso pode lançar ConcurrentModificationException. Reúna os candidatos primeiro e depois remova-os:

ArrayList<Person> toRemove = new ArrayList<>();
for (Person p : people) {
    if (p.getName().equals("Lin")) {
        toRemove.add(p);
    }
}
people.removeAll(toRemove);

O percurso termina antes que a composição da lista mude. removeAll usa igualdade, então remove entradas iguais aos candidatos reunidos.

Uma classe pode manter uma lista em um campo privado e oferecer operações que descrevam sua finalidade. Uma playlist armazena músicas, conta-as e calcula sua duração. Quem chama seus métodos não deve precisar gerenciar a lista diretamente.

Inicialize e encapsule a coleção

Esta playlist espera objetos Song não nulos com um método seconds():

import java.util.ArrayList;

class Playlist {
    private String name;
    private ArrayList<Song> songs;

    Playlist(String name) {
        this.name = name;
        this.songs = new ArrayList<>();
    }

    void add(Song song) { songs.add(song); }
    int count() { return songs.size(); }

    int totalSeconds() {
        int total = 0;
        for (Song song : songs) {
            total += song.seconds();
        }
        return total;
    }
}

Sem new ArrayList<>(), o campo de referência permanece null; a primeira chamada a add falha. Uma lista vazia já é um objeto utilizável, com tamanho 0.

Para músicas com duração de 210 s, 185 s e 247 s, count() retorna 3. O total cresce de 210 para 395 e depois para 642 s. A divisão inteira por 60 resulta em 10 minutos, com resto de 42 segundos. Um método longest() pode selecionar e retornar a música de 247 s, usando o mesmo padrão de seleção de referência do pacote mais pesado. Defina um resultado de ausência para uma playlist vazia.

Proteja a composição da lista por meio de métodos

Manter songs privado bloqueia o acesso direto ao campo, mas return songs; expõe essa própria lista. Quem chama o método poderia chamar clear() e contornar todas as regras da playlist.

Operações específicas como add, count e totalSeconds mantêm a responsabilidade com a playlist. Seu método add poderia impor um tamanho máximo ou recusar duplicatas com songs.contains(song). Verificações de duplicidade baseadas em conteúdo precisam que o equals da classe de música defina quais campos tornam duas músicas iguais.

Quando um construtor receber uma lista inicial, copie sua estrutura com this.songs = new ArrayList<>(initialSongs);. Armazenar o parâmetro diretamente permitiria que quem chamou o construtor mantivesse um apelido de referência à lista interna da playlist.

Uma nova lista ainda pode compartilhar músicas

Uma consulta pode retornar new ArrayList<>(songs). Isso é uma cópia superficial: um novo objeto de lista que contém as referências existentes às músicas.

Uma consulta songsLongerThan(200) cria uma nova lista de resultados, percorre as músicas armazenadas e adiciona aquelas cuja duração excede 200 s. Para as três músicas acima, ela retorna as músicas de 210 s e 247 s. Quando os valores das músicas também precisarem ser independentes, copie as músicas mutáveis ou torne Song imutável.

Identidade verifica se duas referências apontam para o mesmo objeto. Igualdade de conteúdo verifica se objetos têm os mesmos dados relevantes, de acordo com as regras da classe. Dois objetos de livro separados podem descrever o mesmo título e ano de publicação sem serem idênticos.

Escolha a comparação adequada

Toda classe herda equals(Object) de Object. Essa versão padrão verifica a identidade. Java não inspeciona automaticamente todos os campos de uma nova classe.

String a = "java";
String b = new String("java");
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

new String cria um objeto separado, enquanto String.equals compara seus caracteres. A comparação de texto distingue maiúsculas e minúsculas: "Java".equals("java") é falso. equalsIgnoreCase faz uma comparação sem essa distinção quando essa é a regra desejada.

Por que a identidade às vezes parece comparar conteúdo

Literais de string iguais compartilham um objeto de cadeia de caracteres, então "java" == "java" é verdadeiro. Isso pode ocultar um erro em um teste pequeno. Um texto obtido de uma entrada ou construído durante a execução de um programa não precisa compartilhar esse objeto. Use equals para comparar conteúdo, independentemente de como o texto foi obtido.

Comparações de objetos empacotadores têm uma armadilha semelhante:

Integer a = 127, b = 127;
Integer c = 1000, d = 1000;
System.out.println(a == b);      // true
System.out.println(c.equals(d)); // true

O empacotamento automático reutiliza objetos Integer para valores de -128 a 127. O fato de valores maiores compartilharem ou não um objeto não é uma regra portátil de comparação numérica. Em uma configuração padrão, os dois objetos empacotadores de 1000 são separados, mas um cache maior é permitido. Use o equals do tipo empacotador para comparar seus valores ou compare valores primitivos. Se um lado de == for um int, Java desempacota o objeto empacotador e compara valores numéricos; desempacotar um objeto empacotador nulo falha.

Decida quais campos definem a igualdade

Para um catálogo de livros, título e ano de publicação podem definir a igualdade, enquanto quem está com o livro emprestado é ignorado. Esses campos selecionados devem orientar o método de igualdade. Outro programa poderia escolher um identificador único; a regra útil depende do que seus objetos representam.

Um ArrayList usa equals em contains, indexOf e remove(Object). Suponha que Book apenas armazene campos e herde equals. Adicionar um new Book("Dune", 1965) não torna contains(new Book("Dune", 1965)) verdadeiro: a segunda expressão cria um objeto diferente. Sobrescrever a igualdade por título e ano permite que uma busca encontre esse conteúdo igual.

HashSet e HashMap também usam hashCode para reduzir o conjunto de objetos candidatos antes de verificar a igualdade. Portanto, definir igualdade de conteúdo também exige uma regra correspondente de código de dispersão.

Um método de igualdade deve substituir o equals(Object) herdado e comparar os campos que definem o significado do objeto. A assinatura correta é tão importante quanto as comparações dentro do método.

Um padrão completo de igualdade

Esta classe usa título e ano, permite um título nulo e mantém fixos os campos de igualdade:

import java.util.Objects;

final class Book {
    private final String title;
    private final int year;

    Book(String title, int year) {
        this.title = title;
        this.year = year;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Book)) {
            return false;
        }
        Book book = (Book) other;
        return year == book.year
            && Objects.equals(title, book.title);
    }

    @Override
    public int hashCode() {
        return Objects.hash(title, year);
    }
}

Leia equals em quatro etapas. A verificação de identidade aceita imediatamente o mesmo objeto. A verificação de tipo rejeita tudo que não é um livro, incluindo null. A conversão explícita fornece uma variável Book pela qual os campos podem ser lidos. A expressão final verifica os dois campos de igualdade.

O tipo do parâmetro é Object, não Book. Escrever equals(Book other) faz uma sobrecarga do nome com outro método e deixa o equals(Object) herdado inalterado. Uma chamada direta pode então parecer funcionar enquanto ArrayList.contains ainda usa identidade. @Override faz o compilador detectar esse erro de assinatura.

A partir do Java 16, a verificação de tipo e a conversão explícita podem ser combinadas: if (!(other instanceof Book book)) { return false; }. Após a verificação ser bem-sucedida, book fica disponível para comparar os campos.

Adeque as comparações aos tipos dos campos

Use == para campos de tipos inteiros, de caracteres e booleanos. Use o equals de um objeto para seu conteúdo. Para um campo de objeto que pode ser nulo, Objects.equals(a, b) retorna verdadeiro quando ambos são nulos, falso quando apenas um é nulo e, caso contrário, usa igualdade.

Para campos double, Double.compare(x, other.x) == 0 fornece tratamento consistente de valores especiais: dois valores NaN são comparados como iguais, e zero positivo e negativo são distinguidos. Combine essa escolha com uma regra de hash compatível. O == direto de ponto flutuante trata NaN de forma diferente.

Verifique o contrato de igualdade

Para referências não nulas, a igualdade deve ser:

• Reflexiva: x.equals(x) é verdadeiro.
• Simétrica: x.equals(y) e y.equals(x) concordam.
• Transitiva: se x é igual a y e y é igual a z, x é igual a z.
• Consistente: chamadas repetidas concordam enquanto os dados comparados permanecem inalterados.
• Falsa para null: x.equals(null) é falso.

Dois livros para “Dune”, 1965, são comparados como iguais; alterar um dos anos para 1984 os torna desiguais. Um livro não deve ser comparado como igual a uma cadeia de caracteres que contém seu título: a cadeia rejeitaria o livro, violando a simetria.

Algumas implementações usam other == null || getClass() != other.getClass() para verificar o tipo. Isso rejeita classes diferentes em tempo de execução. instanceof pode aceitar subclasses; para a classe final acima, não existe subclasse e as duas verificações concordam.

Um código de dispersão é um inteiro usado para restringir uma busca. HashSet e HashMap o usam para encontrar objetos candidatos e depois usam equals para confirmar uma correspondência. Ele não é um identificador único de objeto.

O contrato vale em uma direção

Objetos iguais devem retornar o mesmo código de dispersão. Objetos desiguais também podem compartilhar um código; isso é uma colisão. Uma colisão não os torna iguais, pois a igualdade ainda é verificada.

Um código de dispersão deve permanecer consistente enquanto as informações usadas por equals não mudarem. Em uma implementação correta, códigos diferentes excluem a igualdade, mas códigos iguais não a estabelecem.

Quando uma classe sobrescreve equals, mas herda Object.hashCode, objetos separados e iguais geralmente recebem códigos diferentes. Um conjunto pode então manter ambos, e uma consulta em um mapa usando uma nova chave igual pode não encontrar a entrada. A falha exata não é garantida, pois objetos diferentes podem ter colisões nos códigos herdados. Corrija o contrato em vez de depender de uma falha específica de consulta.

Calcule a partir dos campos de igualdade

Para a classe de livro que compara título e ano:

@Override
public int hashCode() {
    return Objects.hash(title, year);
}

Importe java.util.Objects. Os mesmos valores de campo agora produzem o mesmo resultado. Um conjunto de livros armazena uma entrada após a adição de dois livros iguais, e um mapa pode recuperar um valor usando uma nova chave de livro igual.

Objects.hash combina os hashes dos campos usando 31. Para “Dune”, o hash da cadeia de caracteres é 2141736. Combinar esse título e o ano 1965 resulta em 31 multiplicado pela soma de 31 e 2141736, mais 1965: o resultado é 66396742.

O cálculo de hash de strings também usa 31. Para “ab”, os códigos de caractere 97 e 98 resultam em 97 multiplicado por 31 mais 98, ou 3105. Cálculos mais longos podem ultrapassar o intervalo de int e dar a volta, então um código de dispersão negativo é normal.

Não altere a chave durante o armazenamento

Suponha que o ano de um livro seja mutável e afete seu código de dispersão. Após a inserção em um conjunto, alterar o ano pode fazer contains(book) falhar mesmo com a mesma referência: a consulta agora busca usando um código diferente. O conjunto ainda pode informar tamanho 1.

Mantenha estáveis os campos de igualdade enquanto um objeto for elemento de um conjunto ou chave de um mapa. Se eles precisarem mudar, remova o objeto enquanto seus valores antigos ainda estiverem em vigor, altere-o e insira-o novamente. Tentar removê-lo somente após a alteração pode causar o mesmo problema de consulta.

A igualdade gerada ainda precisa de uma escolha adequada de dados

Java 16 e versões posteriores oferecem records, como record Book(String title, int year) {}. Um record gera os métodos de acesso title() e year(), além de igualdade, hash e uma representação textual legível a partir de todos os seus componentes. Os campos dos componentes são final. Esse exemplo é um valor imutável útil porque seus componentes são uma cadeia de caracteres e um inteiro; um record que armazenasse uma lista mutável ainda compartilharia o estado dessa lista.

Para classes comuns, uma IDE pode gerar equals e hashCode juntos. Selecione os campos que definem a igualdade desejada e mantenha os dois métodos alinhados quando essa escolha mudar.

A interface do usuário lê entradas e exibe saídas. A lógica do programa armazena dados e aplica regras. Um projeto separado passa valores para a lógica e recebe resultados; suas classes de lógica não usam Scanner nem System.out.

Conecte os objetos em main

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    TemperatureLog log = new TemperatureLog();
    UserInterface ui = new UserInterface(scanner, log);
    ui.start();
}

Com import java.util.Scanner;, essa montagem cria um leitor de entrada, um registro e uma interface. Ela pertence à classe de entrada do programa. UserInterface armazena os objetos fornecidos em campos para que todos os comandos trabalhem com o mesmo registro.

Retorne valores que qualquer chamador possa usar

Um registro pode fornecer add(double celsius), count(), average() e max(). Leituras de 18,5, 21,0 e 19,5 °C têm soma 59,0, contagem 3, máximo 21,0 e média de aproximadamente 19,6667 °C. A interface pode arredondar a média retornada com Math.round(average * 10) / 10.0 e exibir 19,7 °C.

Retornar o número facilita verificações diretas. Um método chamado printAverage() que apenas exibe o resultado acopla um cálculo à saída no console, o que dificulta a reutilização.

Para um laço simples de comandos, suponha que add aceite temperaturas válidas e count retorne sua quantidade:

class UserInterface {
    private Scanner scanner;
    private TemperatureLog log;

    UserInterface(Scanner scanner, TemperatureLog log) {
        this.scanner = scanner;
        this.log = log;
    }

    void start() {
        while (true) {
            String command = scanner.nextLine();
            if ("quit".equals(command)) {
                break;
            }
            if ("count".equals(command)) {
                System.out.println(log.count());
            }
        }
    }
}

O laço cuida da interação. Ele solicita um resultado ao registro e o exibe sem saber como as leituras são armazenadas. Um comando de média deve tratar um registro vazio de acordo com o resultado documentado da lógica ou verificar count() antes de chamar um método que exige leituras.

Valide no ponto adequado

A lógica pode fazer add retornar falso sem armazenar uma leitura abaixo de -273,15 °C. Assim, todos os chamadores recebem a mesma regra de dados. A interface decide como informar essa rejeição e solicitar a entrada novamente. Converter uma entrada não numérica em uma mensagem de erro útil também é tarefa da interface.

Use um Scanner para System.in e passe-o aos leitores. Vários scanners podem disputar entradas armazenadas em buffer, e fechar um deles fecha o fluxo de entrada subjacente. Mantenha o tempo de vida do scanner compartilhado sob controle do código responsável pela entrada do programa.

A lógica pode mais tarde atender a outra interface por meio dos mesmos métodos públicos. A reutilização vem de manter cálculos e regras de validade disponíveis como resultados de métodos, independentemente de um laço de comandos específico.

Um programa separado pode crescer com uma pequena alteração por vez. Dê à lógica um método útil, verifique-o diretamente e depois conecte um comando que reúna suas entradas e exiba seu resultado.

Adicione uma consulta à lógica

Um TemperatureLog que armazena um ArrayList<Double> readings inicializado pode contar leituras acima de um limite:

int countAbove(double limit) {
    int count = 0;
    for (double reading : readings) {
        if (reading > limit) {
            count++;
        }
    }
    return count;
}

A comparação estrita exclui leituras exatamente iguais ao limite. Para 18,5, 21,0, 19,5 e 23,0 °C, countAbove(20.0) retorna 2. Coloque a comparação no registro para que todos os chamadores recebam a mesma regra.

O comando da interface lê um limite, chama log.countAbove(limit) e exibe a contagem. Se cada comando ficar longo, divida start() em métodos auxiliares privados como addReading() e showStatistics(). Os métodos auxiliares organizam a interação; eles não retiram as regras de dados do registro.

Verifique sem digitar comandos

Crie o objeto de lógica e chame seus métodos com valores cujas respostas você conhece:

TemperatureLog log = new TemperatureLog();
log.add(18.5);
log.add(21.0);
log.add(19.5);
log.add(23.0);
System.out.println(log.count() == 4);
System.out.println(log.average() == 20.5);
System.out.println(log.max() == 23.0);
System.out.println(log.countAbove(20.0) == 2);

A soma é 82,0, então a média esperada é 20,5. Esses valores específicos têm representações binárias exatas, tornando essas verificações diretas de igualdade adequadas para o exemplo. Verifique também um registro vazio de acordo com seu comportamento documentado, um limite igual a uma leitura e a rejeição de uma entrada inválida sem alterar a contagem. Ferramentas de teste automatizado se baseiam na mesma ideia de uma entrada conhecida e um resultado esperado.

Altere o armazenamento apenas quando ele ainda atender às consultas

Uma interface que chama apenas average, count e max não precisa saber se o registro armazena uma lista. Campos de soma acumulada, contagem e máximo podem responder a essas três consultas sem manter todas as leituras.

Uma consulta arbitrária countAbove(limit) precisa de mais informações. As amostras 18, 22, 23 e 20, 20, 23 têm a mesma soma 63, contagem 3 e máximo 23, mas suas contagens acima de 20 são 2 e 1. Manter apenas essas três medidas agregadas perde a distinção. Os métodos públicos descrevem o que deve continuar funcionando após uma alteração de armazenamento.

Combine as ideias de projeto

Um livro de receitas pode ser proprietário de uma lista privada de receitas. Cada receita pode conter ingredientes medidos em gramas e um tempo de preparo em minutos. A igualdade pode ajudar nas verificações de duplicidade, enquanto uma interface adiciona, lista e busca receitas por meio dos métodos do livro. Uma lista de resultados copiada pode proteger sua composição e ainda compartilhar objetos de receita; decida se os chamadores podem alterar essas receitas.

Trabalhe em pequenas etapas: implemente um método, verifique-o e depois adicione seu comando. Se uma alteração prejudicar um resultado existente, volte a um estado funcional e isole essa alteração antes de adicionar outro recurso.