[Noções básicas de Java] Qual é a diferença entre == e iguais?
Existem duas maneiras de testar se duas variáveis são iguais em um programa Java, uma é usar o operador == e a outra é usar o método equals ().
1. Interpretação de "=="
O efeito de == para tipos básicos e tipos de referência é diferente, conforme mostrado abaixo:
(1). Tipos básicos: tipos básicos são armazenados na pilha, e para tipos básicos == A comparação é se os valores são os mesmos.
Oito tipos básicos: byte, short, int, long, float, double, char, boolean
int i=8;
double x=8.00;
System.out.println(i==x); // true
(2) Tipo de referência: Para tipos de referência == compara se os endereços de dois objetos são iguais, ou seja, se eles se referem ao mesmo objeto.
String x = "string";
String y = "string";
String n=new String("string");
System.out.println(x==y); //true
System.out.println(x==n); // false
Interpretação de código: para variáveis no pool constante, porque xey apontam para a mesma referência, == é verdadeiro e o novo método String () é reescrito para abrir espaço de memória, então o resultado de == é falso.
2. "equals" interpreta
o endereço usado para comparar objetos, então sua comparação de tipos de referência tem o mesmo efeito que ==. Equals é essencialmente ==, exceto que String e Integer reescreveram o método equals e o alteraram para se tornar um valor comparação.
Em primeiro lugar, vamos ver equals comparando um objeto com o mesmo valor por padrão. O código é o seguinte:
class Cat {
public Cat(String name) {
this.name = name;
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Cat c1 = new Cat("张三");
Cat c2 = new Cat("张三");
System.out.println(c1.equals(c2)); // false
O resultado está além da nossa expectativa, mas acabou sendo falso. Qual é o problema? Basta ler o código-fonte igual, o código-fonte é o seguinte:
public boolean equals(Object obj){
return (this == obj);
}
Acontece que igual é essencialmente ==.
Portanto, a questão é: por que dois objetos String com o mesmo valor retornam true? código mostrado abaixo:
String s1 = new String("老王");
String s2 = new String("老王");
System.out.println(s1.equals(s2));//3true
Da mesma forma, inserimos o método equals de String para encontrar a resposta, o código é o seguinte:
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
Acontece que String reescreve o método equals de Object, mudando a comparação de referências para comparação de valores.
Resumo: == é uma comparação de valor para tipos básicos e uma referência para tipos de referência; e equals é uma comparação de referência por padrão, mas muitas classes renovaram o método equals, como String, Integer, etc. para transformá-lo em Value comparação, então, em geral, igual compara se os valores são iguais.
Extensão igual:
para igual, jdk dá algumas explicações.
O método equals implementa a relação de equivalência em referências de objetos não nulos:
(1). Reflexividade: Para qualquer valor de referência não nulo x, x.equals (x) deve retornar verdadeiro.
(2). É simétrico: para qualquer valor de referência não nulo x e y, x.equals (y) deve retornar verdadeiro se e somente se y.equals (x) retornar verdadeiro.
(3). Transitividade: para qualquer valor de referência não nulo x, y e z, se x.equals (y) retornar verdadeiro e y.equals (z) retornar verdadeiro, então x.equals (z) deve retornar verdadeiro.
(4). É consistente: para qualquer valor de referência não nulo x e y, várias chamadas para x.equals (y) sempre retornam verdadeiro ou sempre retornam falso, e não há informações usadas na configuração de igual em comparação com o objeto sendo modificado.
(5). Para qualquer valor de referência não vazio x, x.equals (nulo) deve retornar falso.
Também há algo a se notar:
o método da classe equals Object implementa a relação de igualdade com a maior diferença possível no objeto; ou seja, para qualquer valor de referência não vazio x e y, se e somente se x e y se referem ao mesmo objeto (x == y tem o valor verdadeiro), o método retorna verdadeiro.
Observe que sempre que você substituir esse método, geralmente precisará substituir o método hashCode para manter o contrato comum do método hashCode, que estipula que objetos iguais devem ter códigos hash iguais.
Link da postagem do blog de referência: https://blog.csdn.net/yujing1314/article/details/105898947