java: Comparator and Treeset to remove duplicates

Question

i have a java class like this

public class A {

    private String field1;
    private String field2;

    // getters, setters but no equals and hashcode
}

and a list of objects of this class, i want to remove from this list all the duplicates elements that has the same field1 or the same field2, so i have 2 Comparators

public class Comparator1 implements Comparator<A> {
    public int compare(A o1, A o2) {

        return o1.getField1().compareToIgnoreCase( o2.getField1() );
    }
}

public class Comparator2 implements Comparator<A> {
    public int compare(A o1, A o2) {

        return o1.getField2().compareToIgnoreCase(o2.getField2());
    }
}

so to do the task i use treeset like

TreeSet<A> ts1 = new TreeSet<A>(new Comparator1())
ts1.addAll(list)

TreeSet<A> ts2 = new TreeSet<A>(new Comparator2())
ts2.addAll(ts1)

list.clear()
list.addAll(ts2)

but how can i do the same using just one comparator and one treeset ?

Thanks for the help

Update:

Thanks all for the answers, but after reading them i don't know if this is the right approach to the real problem.

In my real case field1 is like a phone number and field2 is like a name. So i don't want to call the same phone number more than one time (this is the first treeset to removes duplicates) and i don't want to call more than one time the same name (the second treeset to removes duplicates)

You can modify the class but i'd like to know if this approach is ok to resolve the real problem.

If this approach is correct, from your question, i see that without modifying the class is not possible to use just one comparator

Thanks

Answer 1

You can't use one comparator to sort by two criteria at the same time, so there is no real way to go better than two TreeSets in your case. Of course, you can wrap them in one data structure.

(Alternatively you could use two HashMaps, each having one of the strings as key - this will be faster on average, but is more complicated to program.)

Answer 2

You can't, and it's not clear to me that what you're trying to do is well-defined.

Are you aware that your current approach depends both on the order in which elements are added and on whether you check field1 or field2 first for duplicates? Imagine you had these objects of class A:

A ab = new A("a", "b");
A cb = new A("c", "b");
A cd = new A("c", "d");

Checking field1 first gives the result [ab] or [ab, cd], depending on the order added.

Checking field2 first gives the result [cb] or [ab, cd], depending on the order added.

This is pretty strange behavior. Is this what you intended? I don't think it is possible to reproduce this with a single TreeSet and Comparator in the general case.