Un objeto es una instancia de una clase que tiene su estado y comportamiento. En Java, al estar orientado a objetos, el recolector de basura siempre lo crea dinámicamente y lo destruye automáticamente cuando el alcance del objeto finaliza.
Ilustración: Un ejemplo para ilustrar un objeto de una clase:
Muebles silla=nuevo Muebles();
Muebles sofá = muebles nuevos();
// Aquí, la silla y el sofá son dos objetos de la clase Mobiliario
Enfoques:
Hay dos métodos estándar:
- Usando iguales()
- sin anular
- Con anulación
- Usando el método hashCode() y equals()
Ejemplo 1: aunque el método equals() se puede usar para comparar los valores de dos strings, no es realmente útil por defecto para comparar dos objetos sin anularlo.
Java
// Java Program to compare two objects
// Importing java input output library
import java.io.*;
// Class 1
class Pet {
// attributes of class1
String name;
int age;
String breed;
// constructor of class 1
Pet(String name, int age, String breed)
{
// Assignment of current attributes
/// using this keyword with same
this.name = name;
this.age = age;
this.breed = breed;
}
}
/* Class 2 : where execution is shown
for class 1 */
public class GFG {
// Main driver method
public static void main(String args[])
{
// Objects of class1 (auxiliary class)
// are assigned value */
Pet dog1 = new Pet("Snow", 3, "German Shepherd");
Pet cat = new Pet("Jack", 2, "Tabby");
Pet dog2 = new Pet("Snow", 3, "German Shepherd");
// Checking objects are equal and
// printing output- true/false
System.out.println(dog1.equals(dog2));
}
}
false
Ejemplo 2: anular el método equals()
Aunque los valores de dog1 y dog2 son los mismos, el método equals() siempre comprueba la referencia de los dos objetos, es decir, si ambos objetos pasados se refieren al mismo objeto o no y no a sus valores. Por lo tanto, es recomendable no utilizar este método para comparar objetos sin anularlo. Implementando el método equals para el ejemplo anterior:
Java
// Java Program to Compare Two Objects
import java.io.*;
class Pet {
String name;
int age;
String breed;
Pet(String name, int age, String breed)
{
this.name = name;
this.age = age;
this.breed = breed;
}
@Override public boolean equals(Object obj)
{
// checking if the two objects
// pointing to same object
if (this == obj)
return true;
// checking for two condition:
// 1) object is pointing to null
// 2) if the objects belong to
// same class or not
if (obj == null
|| this.getClass() != obj.getClass())
return false;
Pet p1 = (Pet)obj; // type casting object to the
// intended class type
// checking if the two
// objects share all the same values
return this.name.equals(p1.name)
&& this.age == p1.age
&& this.breed.equals(p1.breed);
}
}
public class GFG {
public static void main(String args[])
{
Pet dog1 = new Pet("Snow", 3, "German Shepherd");
Pet cat = new Pet("Jack", 2, "Tabby");
Pet dog2 = new Pet("Snow", 3, "German Shepherd");
System.out.println(dog1.equals(dog2));
}
}
true
Ejemplo 3: En el ejemplo anterior, el método equals() verifica si todos los valores coinciden o no. Sin embargo, se puede anular de cualquier manera posible, es decir, si uno o dos valores coinciden, etc. Por ejemplo, si queremos verificar dos valores cualesquiera para hacer que el método equals() considere que los dos objetos son iguales:
Java
// Java Program to Compare Two Objects
// Importing java input/output libraries
import java.io.*;
// Class 1
class Pet {
// Attributes of objects
String name;
int age;
String breed;
// Constructor
Pet(String name, int age, String breed)
{
// Assigning current there it self
// using this keyword
this.name = name;
this.age = age;
this.breed = breed;
}
@Override public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null
|| this.getClass() != obj.getClass())
return false;
Pet p1 = (Pet)obj;
// Checking only if attribute- name
// and age is same and ignoring breed
return this.name.equals(p1.name)
&& this.age == p1.age;
}
}
public class GFG {
// Main driver method
public static void main(String args[])
{
// Assigning values to attributes of object
// of class 1
Pet dog1 = new Pet("Snow", 3, "German Shepherd");
Pet cat1 = new Pet("Jack", 2, "Tabby");
Pet dog2 = new Pet("Snow", 3, "German Shepherd");
Pet cat2 = new Pet("Jack", 2, "Persian");
// Checking if object are equal and
// printing boolean output
System.out.println(cat1.equals(cat2));
}
}
true
Usando hashCode() y equals()
Este método es más como un complemento del anterior. Verificar los valores hash usando hashCode() antes de ingresar equals() reduce drásticamente el tiempo necesario para producir la solución. De esta forma, muchas comparaciones entre dos objetos no necesitan pasar por la comparación de todos los valores dentro de ellos.
Ejemplo 1: la implementación anterior junto con el uso de hashCode() :
Java
// Java Program to Compare Two Objects
// Importing java input/output libraries
import java.io.*;
// Class 1
class Pet {
// Attributes of objects of class
String name;
int age;
String breed;
// Constructor
Pet(String name, int age, String breed)
{
this.name = name;
this.age = age;
this.breed = breed;
}
// Overriding using hashCode() method
@Override public int hashCode()
{
/* overriding hashCode() method
to check the length of the names */
return this.name.length() % 10;
}
// Boolean function to check
@Override public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null
|| this.getClass() != obj.getClass())
return false;
Pet p1 = (Pet)obj;
return this.name.equals(p1.name)
&& this.age == p1.age && this.breed == p1.breed;
}
}
// main class (class2)
public class GFG {
// Main driver method
public static void main(String args[])
{
// Assigning values to object of class 1(Pet class)
Pet dog1 = new Pet("Snow", 3, "German Shepherd");
Pet cat1 = new Pet("Jack", 2, "Tabby");
Pet dog2 = new Pet("Snow", 3, "German Shepherd");
Pet cat2 = new Pet("Jack", 2, "Persian");
/* hashCode() generates true as the lengths of
the name value of the two objects are same*/
// Condition check using hashCode() method
if (dog1.hashCode() == cat1.hashCode())
/* On entering equals() method, it checks for
other values and hence, returns false */
System.out.println(dog1.equals(cat1));
else
System.out.println("Not equal");
}
}
false
Ejemplo 2:
Java
// Java Program to Compare Two Objects
import java.io.*;
class Pet {
String name;
int age;
String breed;
Pet(String name, int age, String breed)
{
this.name = name;
this.age = age;
this.breed = breed;
}
@Override public int hashCode()
{
// overriding hashCode() method to first
// check the length of the names*/
return this.name.length() % 10;
}
@Override public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null
|| this.getClass() != obj.getClass())
return false;
Pet p1 = (Pet)obj;
return this.name.equals(p1.name)
&& this.age == p1.age && this.breed == p1.breed;
}
}
public class GFG {
public static void main(String args[])
{
Pet dog1 = new Pet("Snow", 3, "German Shepherd");
Pet cat1 = new Pet("Jack", 2, "Tabby");
Pet dog2 = new Pet("Snow", 3, "German Shepherd");
Pet cat2 = new Pet("Jack", 2, "Persian");
Pet dog3 = new Pet("Ray", 1, "Siberian Husky");
// here, hashCode() generates false and condition
// reverts to the else statement as soon as it finds out
// the lengths of the name value of the objects are
// differenT
if (dog1.hashCode() == dog3.hashCode())
System.out.println(dog1.equals(dog3));
else
System.out.println("Not equal");
}
}
Not equal
Publicación traducida automáticamente
Artículo escrito por dikshapatro y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA