Unique classes in generic list

Question

I have a generic class with a generic list in it. I want to ensure that the generic list only contains unique classes.

What I have done so far is to compare the class names with reflection (getClass()). But I think that's not a clean solution. Are there any better practices to check?

public class MyGenericClass<T extends MyGenericClass.MyInterface> {
  private List<T> members = new ArrayList<>(0);

  public void add(T t) {
    final boolean[] classInMembers = {false};

    members.forEach(member -> {
      if (member.getClass().getName().equals(t.getClass().getName())) {
        classInMembers[0] = true;
      }
    });

    if (!classInMembers[0]) {
      members.add(t);
    }
  }

  public interface MyInterface {
    void doSomething(String text);
  }
}

public class Main {
  public static void main(String[] args) {
    MyGenericClass<MyGenericClass.MyInterface> myGenericClass = new MyGenericClass<>();

    myGenericClass.add(new Performer1());
    myGenericClass.add(new Performer2());
    myGenericClass.add(new Performer3());
    myGenericClass.add(new Performer3()); // should not be inserted!
  }

  private static class Performer1 implements MyGenericClass.MyInterface {
    @Override
    public void doSomething(String text) {
      text = "Hi, I am performer 1!";
    }
  }

  private static class Performer2 implements MyGenericClass.MyInterface {
    @Override
    public void doSomething(String text) {
      text = "Hi, I am performer 2!";
    }
  }

  private static class Performer3 implements MyGenericClass.MyInterface {
    @Override
    public void doSomething(String text) {
      text = "Hi, I am performer 3!";
    }
  }
}

Answer 1

Don't use a List, use a java.util.Set instead.

A collection that contains no duplicate elements. More formally, sets contain no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element.

If the iteration order is important or if you want to use a custom Comparator, the TreeSet implementation can be used:

A NavigableSet implementation based on a TreeMap. The elements are ordered using their natural ordering, or by a Comparator provided at set creation time, depending on which constructor is used.

Example of a Set using a Comparator:

class MyComparator implements Comparator<Object> {
    @Override
    public int compare(Object e1, Object e2) {
        if (e1.getClass() == e2.getClass())
            return 0;
        //if you wish to have some extra sort order                
        return e1.getClass().getName().compareTo(e2.getClass().getName());
    }
}

. . .

Set mySet = new TreeSet<Object>(new MyComparator());
mySet.add(new Object());
mySet.add(new Object());//same class already in set
mySet.add("wtf");

//mySet.size() is now 2 - the second "new Object()" was not inserted due to the comparator check

Answer 2

You could subclass a java.util.Set interface implementation. It will likely be easiest to subclass java.util.AbstractSet.

By default 'Set' will compare objects by their .equals() method - In your case, this is not sufficient. You will need to override the contains method to ensure that only instances of a unique class are added.

In your overrideen contains, it's probably the same / easier to compare class instances rather than their stringified package name

I.e. use a.getClass() == b.getClass(), rather than a.getClass().getName()

Answer 3

Why so complicated?

public class Main {

    public static void main(String[] args) {
        final Class<?> helloClass = "Hello".getClass();
        final Class<?> worldClass = "World".getClass();
        final Class<?> intClass = Integer.class;

        System.out.println(helloClass.equals(worldClass)); // -> true
        System.out.println(helloClass.equals(intClass)); // -> false
    }
}

Answer 4

You could maintain a roster of members in a Set.

public static class MyGenericClass<T extends MyGenericClass.MyInterface> {

    private List<T> members = new ArrayList<>(0);
    // Add this.
    private Set<Class<?>> roster = new HashSet<>();

    public void add(T t) {
        if (!roster.contains(t.getClass())) {
            members.add(t);
            roster.add(t.getClass());
        }
    }

    private void soundOff() {
        for (T t : members) {
            t.doSomething();
        }
    }

    public interface MyInterface {

        void doSomething();
    }
}

private static class Performer implements MyGenericClass.MyInterface {

    final int n;

    public Performer(int n) {
        this.n = n;
    }

    @Override
    public void doSomething() {
        System.out.println("Hi, I am a " + this.getClass().getSimpleName() + "(" + n + ")");
    }
}

private static class Performer1 extends Performer {

    public Performer1(int n) {
        super(n);
    }

}

private static class Performer2 extends Performer {

    public Performer2(int n) {
        super(n);
    }
}

private static class Performer3 extends Performer {

    public Performer3(int n) {
        super(n);
    }
}

public void test() {
    MyGenericClass<MyGenericClass.MyInterface> myGenericClass = new MyGenericClass<>();

    myGenericClass.add(new Performer1(1));
    myGenericClass.add(new Performer2(2));
    myGenericClass.add(new Performer3(3));
    myGenericClass.add(new Performer3(4)); // should not be inserted!

    myGenericClass.soundOff();
}

Answer 5

You could implement a Wrapper which provides the necessary comparison and add the wrapped instance to the set. This way you don't have to override equals and hashcode in your concrete Performer classes and you don't have to subclass a concrete Set implementation (which you are coupled to. When you subclass a HashSet, you have to use that concrete class. But what if you want to use a LinkedHashSet at some point? You have to override LinkedHashSet as well) , which may be fragile since you have to make sure that the overridden method is consistent with the rest of the class.

class MyGenericClass<T extends MyInterface> {
    private Set<ClassCompareWrapper<T>> members = new HashSet<>();

    public void add(T t) {
        members.add(new ClassCompareWrapper<T>(t));
    }
}

class ClassCompareWrapper<T> {
    T t;

    public ClassCompareWrapper(T t) {
        this.t = t;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (!(o instanceof ClassCompareWrapper))
            return false;
        ClassCompareWrapper<?> that = (ClassCompareWrapper<?>) o;
        return Objects.equals(t.getClass(), that.t.getClass());
    }

    @Override
    public int hashCode() {
        return Objects.hash(t.getClass());
    }

    @Override
    public String toString() {
        return "Wrapper{" +
                "t=" + t +
                '}';
    }
}

Answer 6

Here are a few other ideas.

Using streams:

public void add(T t) {
    if (!members.stream().anyMatch(m -> m.getClass() == t.getClass())) {
        members.add(t);
    }
}

Using AbstractSet and HashMap:

class ClassSet<E> extends AbstractSet<E> {
    private final Map<Class<?>, E> map = new HashMap<>();
    @Override
    public boolean add(E e) {
        // this can be
        // return map.putIfAbsent(e.getClass(), e) != null;
        // in Java 8
        Class<?> clazz = e.getClass();
        if (map.containsKey(clazz)) {
            return false;
        } else {
            map.put(clazz, e);
            return true;
        }
    }
    @Override
    public boolean remove(Object o) {
        return map.remove(o.getClass()) != null;
    }
    @Override
    public boolean contains(Object o) {
        return map.containsKey(o.getClass());
    }
    @Override
    public int size() {
        return map.size();
    }
    @Override
    public Iterator<E> iterator() {
        return map.values().iterator();
    }
}

A HashMap could also be used without wrapping it in a Set. The Set interface is defined around equals and hashCode, so any implementation which deviates from this is technically non-contractual. Additionally, you might want to use LinkedHashMap if the values are iterated often.