Domine o uso de iguais por meio dos exemplos a seguir
package cn.galc.test;public class TestEquals { public static void main(String[] args) { /** * Aqui, o método de construção Cat() é usado para criar dois novos gatos na memória heap * Os dois gatos. são Cor, peso e altura são todos iguais, * mas c1 e c2 nunca serão iguais. Isso ocorre porque c1 e c2 são objetos de referência dos dois gatos na memória heap, *. Ele contém os endereços onde os dois gatos podem ser encontrados, mas como os dois gatos estão armazenados em dois espaços diferentes na memória heap, *c1 e c2 contêm endereços diferentes, então c1 e c2 nunca serão iguais. */ Cat c1 = new Cat(1, 1, 1); c2 ));//false System.out.println("O resultado de c1.equals(c2) é: "+c1.equals(c2));//false }}class Cat { int color, peso, altura; public Cat(int cor, int peso, int altura) { this.color = color; this.weight = peso;Desenhe um diagrama de análise de memória para analisar os resultados da comparação entre c1 e c2
programa:
Gato c1 = novo Gato(1,1,1);Gato c2 = novo Gato(1,1,1);
Após a execução, o layout na memória fica conforme mostrado abaixo:
c1 aponta para um objeto e c2 também aponta para um objeto C1 e c2 contêm os endereços armazenados na memória heap desses dois objetos Cat. Como os dois objetos Cat estão localizados em espaços de armazenamento diferentes, c1 e c2 contêm os endereços de. definitivamente não são iguais, então os dois objetos de referência c1 e c2 definitivamente não são iguais. Portanto, se você executar: "System.out.println(c1==c2);" o resultado impresso será definitivamente falso. Então você cria dois objetos com new. Não se preocupe, as referências dos dois objetos nunca serão iguais. Se forem iguais, um deles será sobrescrito. Se c1 é igual a c2 compara o conteúdo contido nas duas referências c1 e c2, porque as referências dos dois objetos produzidos por new nunca são as mesmas, portanto o conteúdo das duas referências c1 e c2 também nunca é o mesmo. c1 nunca pode ser igual a c2. Portanto, comparar as referências de dois objetos nunca pode tornar os dois objetos iguais ou idênticos.
Para determinar se dois objetos são iguais, você não pode comparar se as referências dos dois objetos são iguais. Você nunca obterá um resultado igual porque as referências dos dois objetos nunca serão iguais, portanto, o método de comparação correto é compará-los diretamente. dois objetos e compare se a essência dos dois objetos é a mesma, ou seja, se o conteúdo dos dois objetos é o mesmo Determine se os dois objetos são iguais comparando se os valores dos atributos dos dois objetos. são iguais.
A classe Object fornece um método equals() para comparar se o conteúdo de dois objetos é igual, portanto, podemos usar este método para comparar se os dois objetos são logicamente "iguais". Por exemplo: c1.equals(c2); Aqui está a chamada ao método equals() herdado da classe Object. Consultando a documentação da API, a definição do método equals na classe Object é a seguinte:
booleano público é igual (objeto objeto)
A implementação padrão do método Equals() fornecido na classe Object é comparar a referência do objeto atual e a referência que você deseja comparar para ver se elas apontam para o mesmo objeto, que é o mesmo que "c1==c2 ". , "c1.equals(c2)" e "c1==c2" são completamente equivalentes. Portanto, usar diretamente o método equals() herdado não pode comparar diretamente se o conteúdo de dois objetos é o mesmo. Por esse motivo, devemos substituir o método equals() e alterar a implementação padrão deste método.
A seguir, reescreva o método equals() herdado na classe Cat:
class Cat { int cor, peso, altura; public Cat(int cor, int peso, int altura) { this.color = color; this.height = height } /** * Isto é reescrever Igualdade; O método equals() herdado da classe Object altera a implementação padrão deste método. * Use nossa própria implementação definida para determinar se dois objetos são logicamente iguais. *Aqui definimos que se a cor, o peso e a altura de dois gatos são iguais, *então pensamos que os dois gatos são logicamente idênticos, ou seja, os dois gatos são “iguais”. */ public boolean equals(Object obj){ if (obj==null){ return false } else{ /** * instanceof é um operador de objeto. * O operador objeto é usado para determinar se um objeto pertence a uma instância de uma classe ou subclasse especificada. * O operador de objeto é uma palavra combinada instanceof. * Este operador é um operador binário. A expressão à esquerda é um objeto e a expressão à direita é uma classe. * Se o objeto à esquerda for um objeto criado pela classe à direita, o resultado da operação é. verdadeiro, caso contrário é falso. */ if (obj instanceof Cat){ Cat c = (Cat)obj if (c.color==this.color && c.weight==this.weight && c.height==this.height){ return true; } } } retornar falso }} Neste momento, execute o comando de impressão no método principal:
public static void main(String[] args) { /** * Aqui, o método de construção Cat() é usado para criar dois novos gatos na memória heap * A cor, o peso e a altura desses dois gatos são iguais. . * Mas c1 e c2 nunca serão iguais Isso ocorre porque c1 e c2 são objetos de referência dos dois gatos na memória heap * contém os endereços onde os dois gatos podem ser encontrados, mas porque os dois gatos estão armazenados no. memória heap Em dois espaços diferentes, * Portanto, c1 e c2 possuem endereços diferentes, portanto, c1 e c2 nunca serão iguais. */ Cat c1 = new Cat(1, 1, 1); c2 ));//false System.out.println("O resultado de c1.equals(c2) é: "+c1.equals(c2));//true }O resultado obtido desta vez é diferente do resultado obtido da última vez sem substituir o método equals():
"System.out.println(c1 == c2);" O resultado impresso ainda é falso, porque o conteúdo das referências dos dois objetos é comparado. são iguais, então o resultado impresso deve ser falso.
"System.out.println(c1.equals(c2));" O resultado impresso é verdadeiro, porque reescrevemos o método equals() na classe Cat e alteramos a implementação padrão deste método. o método Mudar para apenas Se esses dois objetos realmente existem e são ambos gatos, e sua cor, altura e peso são iguais, então os dois gatos são logicamente idênticos e exatamente iguais. Dois gatos, ou seja, esses dois gatos são “iguais”. Portanto, o resultado impresso aqui é verdadeiro.
Então, como comparar dois objetos string quanto à igualdade?
Veja o exemplo a seguir:
classe pública TestEquals { public static void main(String args[]){ String s1 = new String("olá"); String s2 = new String("olá"); : "+(s1 == s2));//falso System.out.println("O resultado de s1.equals(s2) é: "+s1.equals(s2));//true }}Desta vez, os dois objetos string são comparados quanto à igualdade:
System.out.println(s1 == s2);
O resultado impresso ainda é falso, porque as referências dos dois objetos string s1 e s2 são comparadas aqui. As referências dos dois objetos nunca serão iguais, portanto o resultado impresso é falso.
System.out.println(s1.equals(s2));
O resultado impresso é verdadeiro, porque a herança da classe Object é reescrita na classe String (todas as classes são herdadas da classe Object, e a classe String obviamente não é exceção. Se você herdar da classe pai, você terá tudo da classe pai. Atributos e métodos, então a classe Sting também possui o método equals(), e o método equals() herdado também foi reescrito), alterando a implementação padrão deste método.
Na classe String, a implementação do método equals() é substituída assim: compare o objeto string atual com o objeto string especificado O objeto string especificado não pode estar vazio e a sequência de caracteres deste objeto é a mesma da string atual. . As sequências de string dos objetos são iguais. Se essas condições forem atendidas, os dois objetos de string serão iguais.
Portanto, s2 aqui atendeu à condição, então o resultado impresso é verdadeiro.
No futuro, ao comparar dois objetos em uma determinada classe quanto à igualdade, primeiro vá para a documentação da API para descobrir se esta classe substituiu o método equals() herdado da classe Object. Se o método equals() for substituído, o método equals() substituído será chamado ao comparar se dois objetos são iguais. Se não for substituído, aquele herdado da classe Object será chamado diretamente. usa a implementação padrão do método equals() para comparar se dois objetos são iguais. Portanto, cada classe pode substituir o método equals() herdado da classe Object conforme necessário.
Para encontrar uma determinada classe no documento da API, se uma classe pode ser usada diretamente sem introduzir um pacote, então esta classe deve estar no pacote java.lang. Por exemplo, a classe String aqui pode ser usada diretamente, então a classe String. deve estar no pacote java.lang. Ao usar uma determinada classe, verifique qual pacote a classe importa e, em seguida, vá até o pacote para encontrar a classe. As classes que não precisam importar pacotes devem estar localizadas em java.lang. .
Geralmente, quando projetamos uma classe, precisamos substituir o método equals da classe pai. Ao reescrever esse método, precisamos projetá-lo de acordo com as seguintes regras:
1. Reflexividade: Para qualquer valor de referência X, o valor de retorno de x.equals(x) deve ser verdadeiro.
2. Simetria: Para qualquer valor de referência x, y, se e somente se o valor de retorno de y.equals(x) for verdadeiro, o valor de retorno de x.equals(y) deve ser verdadeiro;
3. Transitividade: Se x.equals(y)=true, y.equals(z)=true, então x.equals(z)=true
4. Consistência: Se os objetos participantes da comparação não mudarem, o resultado da comparação dos objetos também não deverá mudar.
5. Não nulidade: para qualquer valor de referência não nulo X, o valor de retorno de x.equals(null) deve ser falso
Por exemplo:
public class People { private String firstName; private String lastName; public String getFirstName() { return firstName; } public void setLastName(String lastName) { this.lastName = lastName } public int getAge() { return idade } public void setAge(int idade) { this.age = idade; } @Override public boolean equals(Object obj) { if (this == obj) return true if (obj == null) return false if (getClass() != obj.getClass()) return false; Pessoas other = (Pessoas) obj; if (age != other.age) return false if (firstName == null) { if (other.firstName != null) return false } else if; (!firstName.equals(other.firstName)) retorna falso; if (lastName == null) { if (other.lastName != null) retorna false } else if (!lastName.equals(other.lastName)) retorna falso; ; retornar verdadeiro; }}
Neste exemplo, estipulamos que uma pessoa é a mesma pessoa se seu sobrenome, nome e idade forem iguais. Claro, você também pode adicionar outros atributos. Por exemplo, o número de identificação deve ser o mesmo para ser julgado como a mesma pessoa. Então você pode adicionar o julgamento do número de identificação no método igual!
Resumo: Para comparar se dois objetos são iguais, usamos o método equals(). As condições para julgar se dois objetos são iguais são definidas por nós após reescrever a implementação do método equals(), para que o método equals() possa. ser usado com mais flexibilidade. Compare dois objetos da mesma classe em classes diferentes para ver se eles são iguais.