Question

I’m working on implementing a hierarchy which deals with Comparator and the Comparable interface. Couple of things that are unclear to me:

1. If I’m adding comparators to a comparator chain, what exactly does this piece of code mean

   chain.addComparator(new sortByTitle());

   I know that the sortByTitle() argument has to be a comparator but I don’t understand how you implement a function like this? The comparator requires you to implement the compare(obj1, obj2) function which takes two arguments to compare one against the other, how do you get from that to a single (what looks like a constructor) call with no arguments?

2. Say that I implemented a class called Database which stores some items in an ArrayList called item. The variable item is itself a private variable. Now in the main program, a call like this is made:

   Collections.sort(library.item, chain);

   How is it possible to directly access an object library‘s instance of item? The specification for database states that item needs to be private, can this work?

I would appreciate any help.

Answer 1

• As you probably know, Comparator itself is an interface. When you
  say chain.addComparator(new sortByTitle());, you are passing in an
  instance of an implementation of a Comparator that sorts your object
  by title. The sortByTitle class will in this case implement
  Comparator and will provide an implementation of the
  compare(obj1, obj2) method. which your chain can invoke on that
  instance you pass in. Typically, instead of passing a new instance in every time, all Comparator implementations for an
  Object are declared as public static final members of the Object
  itself.

For example:

public static final Comparator TITLE_COMPARATOR = new Comparator() {
    @Override
    public int compare(Object lhs, Object rhs) {
        // comparison logic
    }
};

You could then simply pass them into you chain in this way:

chain.addComparator(YourObject.TITLE_COMPARATOR);

This has the added benifit of allowing the comparator (which is stateless) to be used elsewhere without creating a new instance every time.

• You would need to write getters and setters (accessors and mutators if you prefer) in the Library class, which will allow the item variable to be read / updated by other classes, even though it is declared as private.

Something like:

public List getItem() {
    return item;
}

and

public void setItem(List item) {
    this.item = item;
}

in the Library class.