Java Programming/Comparing Objects

From Wikibooks, the open-content textbooks collection

Navigate Collection topic: ( v d e ) Introduction Arrays Collection Classes Collection or Map Collection Map Set or List or Queue Set List Queue Map Classes Thread Safe Collections Classes Diagram (UML) Comparing Objects

In Java, we can distingues two kinds of equality.

• Object reference equality : when two object references point to the same object.
• Object value equality : when two separate objects happen to have the same values/state.

Contents 1 Comparing for reference equality 2 Comparing for value equality 3 Sorting/Ordering 4 Change Sorting/Ordering

[edit] Comparing for reference equality

The '==' operator can be used to check if two object reference point to the same object.

if ( objRef1 == objRef2 )
{
    // --- The two object reference point to the same object
}

[edit] Comparing for value equality

To be able to compare two Java objects of the same class the 'boolean equals(Object obj)' method must be overriden and implemented by the class.

The implementor decides which values must be equal to consider two objects to be equal. For example in the below class, the name and the address must be equal but not the description.

public class Customer 
{
  private String name;
  private String address;
  private String description;
...
  public boolean equals(Object obj)
  {
    //if the two objects are equal in reference, they are equal
    if(this == obj)
      return true;
    if (obj instanceof Customer)
    {
      Customer cust = (Customer) obj;
      return cust.getName().equals( this.getName() ) &&
          cust.getAddress().equals( this.getAddress() );
    }
    else
    {
      return false;
    }
  }
}

After the equals() method is overriden, two objects from the same class can be compared as like this:

Customer cust1 = new Customer();
Customer cust2 = new Customer();
...
if ( cust1.equals( cust2 ) )
{
   // --- Two Customers are equal, by name and address ---
}

Note that some VMs may optimize the number of equals call by using the hashCode method. Therefore, it is advisable to override hashCode together with equals. The hashCode method has to ensure that if two objects are equal, their hash codes must be equal.

[edit] Sorting/Ordering

To be able to sort objects from the same class, the class must implement the Comparable interface.

Comparable interface 

imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method.

Since Java 5.0, the Comparable interface is generic; that means when you implement it, you have to specify what your class can be compared to. Usually, this is the same as your class.

public class Customer implements Comparable<Customer>
{
  private String name;
  private String address;
  private String description;
...
  public int compareTo(Customer cust)
  {
    int iRet = ( this.getName()+this.getAddress() ).compareTo( cust.getName()+cust.getAddress() );
    return iRet;
  }
}

In the above code the String class also implements the Comparable<String> interface, so the compareTo() method can be used to compare name and address.

int compareTo(T o) 

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

Lists (and arrays) of objects that implement this interface can be sorted automatically by Collections.sort (and Arrays.sort). Objects that implement this interface can be used as keys in a sorted map or elements in a sorted set, without the need to specify a comparator.

The natural ordering for a class C is said to be consistent with equals if and only if (e1.compareTo((Object)e2) == 0) has the same boolean value as e1.equals((Object)e2) for every e1 and e2 of class C. Note that null is not an instance of any class, and e.compareTo(null) should throw a NullPointerException even though e.equals(null) returns false.

It is strongly recommended (though not required) that natural orderings be consistent with equals. This is so because sorted sets (and sorted maps) without explicit comparators behave "strangely" when they are used with elements (or keys) whose natural ordering is inconsistent with equals. In particular, such a sorted set (or sorted map) violates the general contract for set (or map), which is defined in terms of the equals method.

[edit] Change Sorting/Ordering

Sometimes we may want to change the ordering of a collection of objects from the same class. We may want to order descending or ascending order. We may want to sort by name or by address.

We need to create a class for each way of ordering. It has to implement the Comparator interface.

Since Java 5.0, the Comparator interface is generic; that means when you implement it, you have to specify what type of objects your comparator can compare.

public class CustComparatorByName implements Comparator<Customer>
{
    public int compare(Customer cust1, Customer cust2)
    {
       return cust1.getName().compareTo(cust2.getName());
    }
}

The above class then can be associated with a SortedSet or other collections that support sorting.

Collection<Customer> custSetByName = new TreeSet<Customer>( new CustComparatorByName() );

Using the Iterator the custSetByName collection can be iterated in order of sorted by name.

A List can be sorted by the Collections's sort method.

import java.util.Collections
...
Collections.sort( custList, new CustComparatorByName() );

Sorts the specified list according to the order induced by the specified comparator. All elements in the list must be mutually comparable using the specified comparator

Also an array of objects can be sorted with the help of a Comparator.

import java.util.Arrays
...
Arrays.sort( cust[], new CustComparatorByName() );

Sorts the specified array of Customer objects (cust[] array) according to the order induced by the specified comparator. All elements in the array must be mutually comparable by the specified comparator.