可实例化的Java通用 <E extends Comparable<E> &gt;

Question

I have a class (let's say a trolley [aka. "cart" in en-US]) that loads a bunch of objects that are either strings or integers. The users specifies as input a flag to state how the input should be read. The trolley class only cares that the objects are comparable for sorting. However, I'm having trouble reusing the same trolley object for both string and integers. To explain, here is an MWE:

import java.util.TreeSet;

public class Trolley<E extends Comparable<E>> {
    public TreeSet<E> items;

    public Trolley(){
        items = new TreeSet<E>();
    }

    public boolean addItem(E item){
        return items.add(item);
    }

    public static void main(String args){
        // read from input
        boolean numeric = false;

        Trolley<?> items = null;
        if(numeric)
            items = new Trolley<Integer>();
        else items = new Trolley<String>();

                // items will be parsed from a file
        if(numeric){
                        // compiler warning about generic mismatch
            items.addItem(42);
        } else{
                        // compiler warning about generic mismatch
            items.addItem("42");
        }
    }
}

This gives compiler warnings on the addItem(.) calls.

The trolley will only ever sort the items and print them as strings (ie, whether the input was numeric or string, the subsequent code will not care).

Again this is just an MWE-like analogy of what I want to do (in reality, I want to load a directed graph into memory and loading integers is to save memory if the input has optionally been dictionary encoded beforehand).

---

My question is how can I configure the generics to permit use of the same trolley object to abstract integer and string input?

I've tried a few things such as the above wildcard and such as Trolley<? extends Comparable<?>> items = new Trolley<? extends Comparable<?>>() Trolley<? extends Comparable<?>> items = new Trolley<? extends Comparable<?>>() Trolley<? extends Comparable<?>> items = new Trolley<? extends Comparable<?>>() but that didn't work either. I guess intuitively the problem here is that I could add any objects to the Trolley that may not be comparable with each other like a mix of strings and integers whereas I would like a Trolley object that would accept only one type of Comparable ... but any type.)

(EDIT: I should add, I would prefer to avoid using a wrapper class like Item since this code will be memory constrained.)

Answer 1

A Trolley<?> is a Trolley of a specific type but we don't know which type.

It happens that in your code it may well be a Trolley<Integer> or a Trolley<String> .

So the compiler can't let you add anything but null to that trolley because its actual type will only be determined at runtime.

To make your code compile without too many changes you need to have one branch for Integer and one for String:

public static void main(String args) {
  boolean numeric = false;

  if (numeric) {
    Trolley<Integer> trolley = new Trolley<>();
    trolley.addItem(42);
  } else {
    Trolley<String> trolley = new Trolley<>();
    trolley.addItem("42");
  }
}

Answer 2

The final solution I used (inspired by @assylias' answer):

public static void main(String args) {
  boolean numeric = false;

  Trolley<? extends Comparable<?>> trolley = null;
  if (numeric) {
    Trolley<Integer> trolleyN = new Trolley<Integer>();
    trolleyN.addItem(42);
    trolley = trolleyN;
  } else {
    Trolley<String> trolleyS = new Trolley<String>();
    trolleyS.addItem("42");
    trolley = trolleyS;
  }

  // use trolley in "read-only" mode
}