1

I am attempting to create a custom list object in Java that is to have parameterized types in "<>" (like ArrayLists). However, these paramaterized types need to implement the Comparable interface (because the list will be automatically sorted and organized).

The problem I am having is with syntax and ensuring that 1) the list elements are Comparable Objects, not just any Objects, and 2) getter methods like get(index) should return Objects of the type for the list without requiring the cast, i.e. if a list is created paramaterized with < Integer >, get() should have a return type of Integer, not Comparable or Object.

I know that parameterized objects in Java can be created using things like < E > and < T >, but this does not allow me to require that the elements of the list be Comparable.

By the way, if you have any comments like "Just use ArrayList or LinkedList." or "Why are you using a custom list, stupid?", please keep them to yourself. I want to create a well-organized, efficient list system that doesn't fit with any existing structures. The Comparable requirement is necessary for the list to be sorted automatically.

If anyone could give me an idea of how to do this, it would be greatly appreciated.

Variadicism
  • 624
  • 1
  • 7
  • 17

3 Answers3

1

Comparable Objects:

<V extends Comparable<V>>

qqilihq
  • 10,794
  • 7
  • 48
  • 89
1

When defining a type parameter you can use the extends keyword to specify that your class may only accept a type argument that has a certain supertype (Comparable, in your case).
As for the get method - just use the same type argument as the return type. E.g.:

public class MyList<T extends Comparable<T>> {

    public T get(int index) {
        ...
    }
}
Mureinik
  • 297,002
  • 52
  • 306
  • 350
0

You should declare your generic type parameter with an upper bound of Comparable to guarantee that the items are Comparable. However, Comparable itself has a type parameter, usually to itself. E.g. Integer implements Comparable<Integer>.

Does T extends Comparable<T> work? Sure, but if Superclass implements Comparable<Superclass>, then a subclass Subclass also implements Comparable<Superclass>. To account for that possibility, introduce a wildcard with a lower bound of T.

public class CustomParameterizedList<T extends Comparable<? super T>>

This follows existing patterns in standard Java, such as Collections.sort, which defines T similarly.

public static <T extends Comparable<? super T>> void sort(List<T> list)

The Java Generics tutorial has explanations as to why <T extends Comparable<? super T>> is more flexible than <T extends Comparable<T>>.

It isn't necessary that T be comparable to exactly itself. All that's required is that T be comparable to one of its supertypes. This give us:

public static <T extends Comparable<? super T>> 
        T max(Collection<T> coll)
Community
  • 1
  • 1
rgettman
  • 176,041
  • 30
  • 275
  • 357
  • I see. Thank you for the extended description. It was very helpful. I find it odd that the keyword `extends` is used instead of `implements` considering Comparable is an interface, but the compiler accepts it. I think I might use the wildcard as you suggested, too. Thanks again. – Variadicism Feb 26 '14 at 01:14
  • It's one of the quirks of Java generics in that "extends" applies to classes and interfaces when specifying an upper bound. For more detail, see [Java generics - why is “extends T” allowed but not “implements T”?](http://stackoverflow.com/questions/976441/java-generics-why-is-extends-t-allowed-but-not-implements-t). – rgettman Feb 26 '14 at 01:18