O método igual na classe de objeto é usado para detectar se um objeto é igual a outro objeto. Na classe de objeto, esse método determina se dois objetos têm a mesma referência. Se os dois objetos tiverem a mesma referência, eles devem ser iguais. Desse ponto de vista, é razoável usá -lo como operação padrão. No entanto, para a maioria das classes, esse julgamento não tem sentido. Por exemplo, é completamente sem sentido comparar se duas formas de impressão são iguais dessa maneira. No entanto, geralmente é necessário detectar a igualdade dos estados de dois objetos. Se os estados dos dois objetos forem iguais, os dois objetos serão considerados iguais. Portanto, em geral, as comparações iguais devem ser reescritas em classes personalizadas.
Aqui estão algumas sugestões para escrever um método perfeito igual ():
(1) O parâmetro explícito é chamado outrobject e precisa ser convertido em uma variável chamada outro posteriormente
(2) Detecte se este e outro objeto se referem ao mesmo objeto:
if (this == OtherObject) retorna true;
Esta afirmação é apenas uma otimização. De fato, essa é uma forma que é frequentemente adotada. Porque calcular essa equação é muito mais barato do que comparar os campos em uma classe um por um.
(3) Verifique se o outro objeto é nulo e, se nulo, retorne false. Este teste é necessário.
if (outrobject == NULL) retorna false;
(4) Compare se este e outro objeto pertencem à mesma classe. Se a semântica da igual mudar em cada subclasse, use getClass () para detectá -lo, que se toma como a classe de destino
if (getClass ()! = OtherObject.getClass ()) retorna false;
Se todas as subclasses tiverem a mesma semântica, use a instância de detecção
if (! (OtherObject instanceOf ClassName)) retorna false;
(5) Converta o outro objeto em uma variável do tipo correspondente:
ClassName Other = (ClassName) OtherObject;
(6) Agora comece a comparar todos os domínios que precisam ser comparados. Use == para comparar o domínio do tipo básico e usar iguais para comparar o domínio do objeto. Retorne true se todos os campos corresponderem, retorne False;
Retornar Field1 == OUTRO
Se a igual for redefinida em uma subclasse, você deve incluir a chamada super.equals (outros). Se a detecção falhar, é impossível ser igual. Se os domínios da superclasse forem iguais, compare os domínios da instância na subclasse.
Para campos do tipo Array, você pode usar o método estático.
Vamos dar uma olhada em alguns exemplos de comparação de strings:
String a = "abc"; String b = "abc"; String c = new String ("ABC"); String d = new string ("abc"); System.out.println (a == b); // true porque as constantes de string são compartilhadas em java, existe apenas um sistema de cópia.out.println (a == c); // false a e c pertencem a 2 objetos diferentes.out.println (A.Equals (c)); // true Como o método igual do objeto String compara os valores no objeto, ele retorna true. (Diferente do método igual do objeto) System.out.println (C == D); // Falso, embora os valores nos objetos sejam iguais, eles pertencem a 2 objetos diferentes, portanto não são iguais de sistema.out.println (c.quals (d)); // verdadeiroSimplificando, ao comparar constantes de string, é o mesmo que o resultado retornado por iguais. Quando você deseja comparar o valor do objeto String, use é igual.
Veja um exemplo de uso igual:
Pacote Capítulo05.Equalstest; importar java.util.*; classe pública Equalstest {public static void main (string [] args) {funcionário alice1 = novo funcionário ("Alice Adams", 75000, 1987, 12, 15); Funcionário alice2 = alice1; // Referenciar o mesmo funcionário do objeto Alice3 = New Funcionário ("Alice Adams", 75000, 1987, 12, 15); Funcionário bob = novo funcionário ("Bob Brandson", 50000, 1989, 10, 1); System.out.println ("alice1 == ALICE2:" + (alice1 == alice2)); System.out.println ("Alice1 == ALICE3:" + (Alice1 == Alice3)); System.out.println ("Alice1.Equals (Alice3):" + (Alice1.Equals (Alice3))); System.out.println ("Alice1.Equals (Bob):" + (Alice1.Equals (Bob))); System.out.println (bob.toString ()); }} classe funcionário {public funcionário (string n, duplo s, int ano, int mês, int dia) {name = n; salário = s; Calendário GregoriaCalendar = New GregorianCalendar (ano, mês, dia); houteray = calendar.gettime (); } public string getName () {return name; } public Double getSalary () {Return Salary; } public data gethireday () {return hireaday; } public void RaiseSalary (duplo de desvio) {duplo aumento = salário * Bypercent / 100; salário += elevação; } @Override public boolean é igual (objeto outrobject) {// Um teste rápido para ver se os objetos são identificados se (this == OtherObject) retorna true; // deve retornar false se o parâmetro explícito for nulo se (outrobject == null) retorna false; // Se a classificação não corresponde, eles não podem ser iguais se (getClass ()! = OtherObject.getClass ()) retornar false; // Agora sabemos que o OtherObject é um funcionário que não é nulo outros = (funcionário) outroObject; // Teste se os campos hava identificaram os valores retorna nome.equals (outros.name) && Salário == OUTRO.SALARY && HIDERAY.EQUALS (OUTROS.HIREDAY); } @Override public int hashCode () {return 7 * name.hashcode () + 11 * novo duplo (salário) .hashcode () + 13 * houteray.hashcode (); } @Override public string tostring () {return getClass (). GetName () + "[name =" + name + ", salário =" + salário + ", houteray =" + houireday + "]"; } nome de string privado; Salário duplo privado; data privada HIREDAY; } Classe Manager estende o funcionário {Public Manager (String n, Double S, Int Ano, Int Month, Int Day) {super (n, s, ano, mês, dia); Bouns = 0; } @Override public duplo getSalary () {duplo basesalary = super.getSalary (); Basesalário de retorno + bola; } public void setbouns (duplo b) {bouns = b; } @Override public boolean é igual (objeto outrobject) {if (! Super.equals (outrobject)) retorna false; Gerente outro = (gerente) outrobject; // Super Equals verificou se este e outro pertencem à mesma classe Return Bouns == Other.bouns; } @Override public int hashCode () {return super.hashcode () + 17 * new Double (Bouns) .hashcode (); } @Override public string tostring () {return super.toString () + "[bouns =" + bouns + "]"; } bouns duplos privados; } Vá mais fundo e divida -o em 2 categorias de acordo com "se a classe substitui o método iguals ()".
(1) Se uma classe não substituir o método iguals (), quando compara os dois objetos através da Equals (), está realmente comparando se os dois objetos são o mesmo objeto. Neste momento, é equivalente comparar esses dois objetos por "==".
(2) Podemos substituir o método iguals () da classe para permitir que o Equals () compare se dois objetos são iguais de outras maneiras. A prática usual é: se o conteúdo de dois objetos forem iguais, o método iguals () retorna true; Caso contrário, ele retorna Fasle.
Em seguida, vamos dar um exemplo para explicar as duas situações acima.
1. O caso de "não substituir o método Equals ()" "
O código é o seguinte (igualstest1.java):
importar java.util.*; importar java.lang.comparable;/*** @desc equals () Programa de teste. */public class Equalstest1 {public static void main (string [] args) {// Crie 2 novos objetos de pessoa com o mesmo conteúdo, // use é igual a comparar se eles são iguais para P1 = nova pessoa ("eee", 100); Pessoa P2 = nova pessoa ("Eee", 100); System.out.printf ("%s/n", p1.equals (p2)); } /*** @DESC Pessoa classe. */ Pessoa de classe estática privada {int Age; Nome da string; Pessoa pública (nome da string, Int Age) {this.name = name; this.age = idade; } public string tostring () {retorna nome + " -" + idade; }}} Resultados em execução:
Copie o código da seguinte maneira: false
Análise de resultados Usamos P1.Equals (P2) para "comparar se P1 e P2 são iguais". De fato, o método iguals () de object.java é chamado, ou seja, o (p1 == p2) chamado. É comparar "se P1 e P2 são o mesmo objeto".
A partir das definições de P1 e P2, podemos ver que, embora o conteúdo deles seja o mesmo, eles são dois objetos diferentes! Portanto, o resultado de retorno é falso.
2. A situação de "sobrescrever o método Equals ()" "
Modificamos o igualstest1.java acima: Substitua o método iguals ().
O código é o seguinte (igualstest2.java):
importar java.util.*; importar java.lang.comparable;/*** @desc equals () Programa de teste. */public class Equalstest2 {public static void main (string [] args) {// Crie 2 novos objetos de pessoa com o mesmo conteúdo, // Use igual a comparar se eles são iguais P1 = nova pessoa ("eee", 100); Pessoa P2 = nova pessoa ("Eee", 100); System.out.printf ("%s/n", p1.equals (p2)); } /*** @DESC Pessoa classe. */ Pessoa de classe estática privada {int Age; Nome da string; Pessoa pública (nome da string, Int Age) {this.name = name; this.age = idade; } public string tostring () {retorna nome + " -" + idade; } / *** @Desc Substitua igual a método* / @Override public boolean equals (objeto obj) {if (obj == null) {return false; } // Se for o mesmo objeto, retorne true, caso contrário, retorne false if (this == obj) {return true; } // julgue se o tipo é o mesmo se (this.getClass ()! = Obj.getclass ()) {return false; } Pessoa pessoa = (pessoa) obj; retornar name.equals (pessoa.name) && Age == Person.age; }}} Resultados em execução:
Copie o código da seguinte maneira: true
Análise de resultados:
Substituímos a função da pessoa igual () em igualstest2.java: quando o nome e a idade dos objetos de duas pessoas são iguais, ele retorna verdadeiro.
Portanto, o resultado da execução retorna verdadeiro.
Dito isto, vamos falar sobre os requisitos de Java para iguais (). Existem os seguintes pontos:
Simetria: Se X.Equals (y) retornar "True", então Y.Equals (x) também deverá retornar "True".
Refletividade: X.Equals (x) deve retornar "True".
Analogia: se x.equals (y) retornar "true" e y.equals (z) retornar "true", então z.Equals (x) também devem retornar "true".
Consistência: Se X.Equals (y) retornará "True", desde que o conteúdo de X e Y permaneça inalterado, não importa quantas vezes você repita X.Equals (y), o retorno será "verdadeiro".
Não vazio, X.Equals (NULL), sempre retorna "falso"; x.equals (objetos de diferentes tipos e x) sempre retorna "false".
Agora, vamos revisar o papel dos iguais (): determinar se dois objetos são iguais. Quando reescrevemos iguais (), é impossível mudar sua função!
Qual é a diferença entre iguais () e ==?
==: sua função é determinar se os endereços de dois objetos são iguais. Ou seja, determine se os dois objetos são o mesmo objeto.
equals (): sua função é determinar se dois objetos são iguais. No entanto, geralmente possui duas condições de uso (foi descrito em detalhes na parte anterior 1):
Caso 1, a classe não substitui o método iguals (). Então, ao comparar dois objetos desta classe através do Equals (), é equivalente a comparar esses dois objetos por "==".
Caso 2, a classe substitui o método iguals (). Geralmente, substituímos o método iguals () para tornar o conteúdo de dois objetos iguais; Se o conteúdo deles for igual, ele retornará verdadeiro (ou seja, os dois objetos são considerados iguais).
Abaixo, compare suas diferenças por exemplos.
O código é o seguinte:
importar java.util.*; importar java.lang.comparable;/*** @desc equals () Programa de teste. */public class Equalstest3 {public static void main (String [] args) {// Crie 2 novos objetos de pessoa com o mesmo conteúdo, // Use Iguals para comparar se eles são iguais para P1 = nova pessoa ("eee", 100); Pessoa P2 = nova pessoa ("Eee", 100); System.out.printf ("P1.Equals (p2): %s/n", p1.equals (p2)); System.out.printf ("p1 == p2: %s/n", p1 == p2); } /*** @DESC Pessoa classe. */ Pessoa de classe estática privada {int Age; Nome da string; Pessoa pública (nome da string, Int Age) {this.name = name; this.age = idade; } public string tostring () {retorna nome + " -" + idade; } / *** @Desc Substitua igual a método* / @Override public boolean equals (objeto obj) {if (obj == null) {return false; } // Se for o mesmo objeto, retorne true, caso contrário, retorne false if (this == obj) {return true; } // julgue se o tipo é o mesmo se (this.getClass ()! = Obj.getclass ()) {return false; } Pessoa pessoa = (pessoa) obj; retornar name.equals (pessoa.name) && Age == Person.age; }}} Resultados em execução:
P1.Equals (P2): Truep1 == P2: false
Análise de resultados:
Em igualstest3.java:
(1) P1.Equals (P2)
Isso é para determinar se o conteúdo de P1 e P2 é igual. Como a pessoa substitui o método iguals (), e este igual () é usado para determinar se o conteúdo de p1 e p2 são iguais, exatamente o conteúdo de p1 e p2 são iguais; Portanto, retorne verdadeiro.
(2) P1 == P2
Isso é para determinar se P1 e P2 são o mesmo objeto. Já que são dois objetos novos de pessoa cada; Portanto, retorne falso.