Actually I don't understand this question in all

Am I on good way?

@Override
        public int compare(T o1, T o2)
        {
            for (Comparator<T> e : comparators)
            {
                if(e.compare(o1, o2) != 0)
                {
                    return e.compare(o1, o2);
                }

            }

            return 0;
        }
    }

That is exactly what I meant, I think that looks good. My only suggestion is to make an int before the if statement that stores e.compare(). Then use that int in the if statement and return the int if it is not 0. This way e.compare is only called 1 time. In my mind I think that would be a better solution CPU wise (computes a little faster or more efficiently). Lines 4-11 would be:

for(...)
}
   int temp = e.compare(...)
   if(temp != 0)
      return temp;
}

It may make no difference though.

Thank You like always man!

hi Guadalupe Please explain why we're doing THREE compares ? I look at this code that they expect, and it's totally not the same thing as in the explanation in the lesson ? Ok, so (1) I deduce that it's asking me to send a list of objects (why it should be of Comparator type, I don't know, as anything can be compared ?) to compare with one another ? (2) the list can be any size. It can be 15 objects, and can have multiple fields, so which field is compared by the "compare" statement ? (3) let's (for the sake of staying sane) assume that the passed array of objects, only has ONE field: an Integer, so it's easy to compare. (4) now the statement itself: e.compare : "e" is the indexed object in the incoming array. So I look at e[0] first, and would think I need to do "e[0].compare(e[1])", then "e[0].compare(e[2]), and so on, until I cycled right through the whole incoming array ? (5) The compare is not comparing all objects with one another. It's comparing "e" with 2 unknown (to me ?) variables "o1" and "o2". So even if I assume that "o1" will be automatically assigned the value of the current iterated object in the array ("e"), I still don't get how "o2" will be automatically assigned a value of one of the objects in the array ? Also, why am I simply stopping as soon as I found the first one that differs from "e" ? What about comparing the 2nd object in the array to all the others, etc ? As you can see, I am not understanding this, will appreciate your explanation, you always break it down properly! Thank you ;)

1a) Yes, but it would more properly be put that the user of your class will be sending a list of Comparator objects. 1b) Comparator is an interface that has a very specific duty, and that is to expose a compare() method that accepts 2 objects of type T and returns a negative number, zero, or positive depending on the conditions coded in (see my first post on this thread). The type T is determined when initialized, so if it is initialized as a string then it would only be comparing strings. The T is used all through the class and when initialized has to all match. You could not initialize a CustomizedComparator<String> object and pass a Comparator<Car> in the constructor. 2) The list can be of any size. Unless you make the Comparator objects you wont have any idea what is being compared. The interface just has a compare() method which will do all the work and return 1 of 3 different results (negative, zero, positive). In the code above that is all the information needed to solve. 3) Comparator objects won’t have fields, just the compare method. This task also uses generics so this code could work with any class. Unless you personally wrote the Comparator object you wouldn't know how it is comparing the objects of its specified type. In the real world with teams of hundreds collaborating with multiple other teams this is a real concern. How are you going to know how the class is going to be sorted individually say if it is initialized in one of these ways: CustomizedComparator<Car> CustomizedComparator<Human> CustomizedComparator<Planet> CustomizedComparator<Pencil> Or any infinite other possible class

4) It sounds like you are confusing Comparator with Comparable. A class that implement Comparable would have a compareTo() method that would work the way that you describe. The Comparator interface would be a class (implementing the interface of course) that works with 2 objects and compares them internally. So:

Object object1 = new Object();
Object object2 = new Object();

// assume on this line that these objects implement Comparable
object1.compareTo(object2); //<< Comparable

// now assume below that the objects do not implement Comparable
Comparator<Object> test = new Comparator<Object>() {
   //(anonymous class because can't instantiate an interface)
   @Override
   public int compare(Object o1, Object o2) {
      // coode that compares the two passed in objects
      return 0; //<< returns result (-1 for less than, 0 for equal, 1 for positive
   }
};

test.compare(object1, object2);

5) I think i answered this already with the rest of my response. A usage of the Comparator interface is in the method ArrayList.sort(). You can pass in a Comparator object to change the default behavior of the sort method to any behavior that you want (limited only by what you are able to actually code). I messaged you an example.

Guadalupe Gagnon, Your little explanation on it just triggered my tube light brain after reading 2 hrs again and again to basically understand what you are saying. Question was little tricky for me. But your explanation below was amazing. Keep going cheers. "now you have a list of custom comparators that are going to sort based on their own criteria using the sort method that you have access to (these comparators have a sort method each that you can call but wont be able to modify). What you want to do is figure out how to call sort on each comparator in the Array, passing the objects o1 and o2 to it, then if the result (an int) is 0 go on to the next level otherwise return that int. If the list completes without returning a value, determine the default value to return."

I can't understand why this is the solution. Let's say we have the following Person class:

public class Person{
        int age;
        int height;
        int weight;
}

Then we pass three comparators to the constructor. The first one compare method's compares age, the second compares the height and the last one compares weight:

MyComparator<Person> myComparator = new MyComparator(comparator1, comparator2, comparator3);
Collections.sort(people, myComparator);

Here the myComparator compare method gets called (I use the method provided by Azja):

@Override
        public int compare(T o1, T o2)
        {
            for (Comparator<T> e : comparators)
            {
                if(e.compare(o1, o2) != 0)
                {
                    return e.compare(o1, o2);
                }
            }
            return 0;
        }
    }

Let's say o1 is Mary{age=23, height=160,weight=50} and o2 is Peter{age=26, height=190,weight=84}. When the if statement is reached, as both ages are different, the return value is not 0. That means that we'll never reach the second comparator unless Peter and Mary were both the same age. Am I right or I'm missing something?

The compare() method returns: a positive int if o1 is greater than o2 0 if o1 is equal to o2 a negative int if o1 is greater than o2 So when that first if is reached (line 6 of your code) and the comparisons are not equal (meaning the result would not be 0), the statement would be true and the next compare would be reached (line 8) and returned.

"My only suggestion is to make an int before the if statement that stores e.compare(). Then use that int in the if statement and return the int if it is not 0." It actually won't pass validation unless you do it this way. Seems a bit rough, lol.