Java 获取对象类并用作泛型构造函数的参数

我肯定以前有人问过这个问题，但我对Java还不熟悉，也不熟悉我正在寻找的确切术语

我有一门BST课程：

public class BinarySearchTree<T extends Comparable> {
    /* ... */
}

公共类二进制搜索树{
/* ... */
}

然后我为它写了一些测试：

public static void main(String[] args) {
    Integer[] integerItems = {1, 7, 8, 2, -1, -10, 100, 12, 32};
    String[] stringItems = {"jungi", "phil", "bob", "leslie", "tyler", "clarence"};
    Comparable[][] comparableLists = {integerItems, stringItems};

    for (Comparable[] list : comparableLists) {
        BinarySearchTree<>...
    }
}

publicstaticvoidmain（字符串[]args）{
整数[]整数项={1,7,8,2，-1，-10,100,12,32}；
String[]stringItems={“jungi”、“phil”、“bob”、“leslie”、“tyler”、“clarence”}；
可比[]可比列表={integerItems，stringItems}；
对于（可比[]列表：可比列表）{
二进制搜索树。。。
}
}

我对这一步感到困惑。如何从列表中恢复类型（字符串[]、整数[]等）并将其用作参数？我想要这样的东西：

for (Comparable[] list : comparableLists) {
    BinarySearchTree<typeOf(list)> root = new BinarySearchTree<typeOf(list)>();
    /* ... tests ... */
}

public static void main(String[] args) {
    Integer[] integerItems = {1, 7, 8, 2, -1, -10, 100, 12, 32};
    String[] stringItems = {"jungi", "phil", "bob", "leslie", "tyler", "clarence"};
    Comparable[][] comparableLists = {integerItems, stringItems};

    for (Comparable[] list : comparableLists) {
        BinarySearchTree<Comparable> root = new BinarySearchTree<Comparable>();

        for (Comparable item : list) {
            root.insert(item);
        }

        System.out.println(root);
    }
}

for（可比[]列表：可比列表）{
BinarySearchTree root=新的BinarySearchTree（）；
/*…测试*/
}

我发现的一个选择就是列出所有可能支持的类型。这看起来很愚蠢，因为我不知道所有支持的类型。也许这些类型会改变，等等，但我有硬编码

我怎样才能最好地处理这个问题

编辑：

更具体地说，这里是BST实现：

public class BinarySearchTree<T extends Comparable> {
    private T value;
    private BinarySearchTree<T> leftChild;
    private BinarySearchTree<T> rightChild;

    public BinarySearchTree() {

    }

    public BinarySearchTree(T v) {
        value = v;
        createChildren();
    }

    public void createChildren() {
        leftChild = new BinarySearchTree<T>();
        rightChild = new BinarySearchTree<T>();
    }

    public void insert(T v) {
        if (value == null) {
            value = v;
            createChildren();
        } else if (v < value) {
            leftChild.insert(v);
        }
        rightChild.insert(v);
    }

    public boolean valueExists(T v) {
        if (value == null) {
            return false;
        } else if (value == v) {
            return true;
        } else if (v < value) {
            return leftChild.valueExists(v);
        }
        return rightChild.valueExists(v);
    }

    public String toString() {
        String bstStringBuilder = "";

        if (value == null) {
            return "";
        }

        bstStringBuilder += leftChild + " ";
        bstStringBuilder += value + " ";
        bstStringBuilder += rightChild;
        return bstStringBuilder;
    }
}

公共类二进制搜索树{
私人T值；
私有二进制搜索树leftChild；
私有二进制搜索树rightChild；
公共二进制搜索树（）{
}
公共二进制搜索树（TV）{
值=v；
createChildren（）；
}
公共儿童{
leftChild=新的BinarySearchTree（）；
rightChild=新的BinarySearchTree（）；
}
公共空白插入（电视）{
如果（值==null）{
值=v；
createChildren（）；
}否则，如果（v<值）{
leftChild.插入（v）；
}
rightChild.插入（v）；
}
公共布尔值存在（tV）{
如果（值==null）{
返回false；
}else if（值==v）{
返回true；
}否则，如果（v<值）{
返回leftChild.valueExists（v）；
}
返回rightChild.valueExists（v）；
}
公共字符串toString（）{
字符串bstStringBuilder=“”；
如果（值==null）{
返回“”；
}
bstStringBuilder+=leftChild+“”；
bstStringBuilder+=值+“”；
bstStringBuilder+=rightChild；
返回StringBuilder；
}
}

如果我使用@OldCurmudgeon的建议，main（）如下所示：

for (Comparable[] list : comparableLists) {
    BinarySearchTree<typeOf(list)> root = new BinarySearchTree<typeOf(list)>();
    /* ... tests ... */
}

public static void main(String[] args) {
    Integer[] integerItems = {1, 7, 8, 2, -1, -10, 100, 12, 32};
    String[] stringItems = {"jungi", "phil", "bob", "leslie", "tyler", "clarence"};
    Comparable[][] comparableLists = {integerItems, stringItems};

    for (Comparable[] list : comparableLists) {
        BinarySearchTree<Comparable> root = new BinarySearchTree<Comparable>();

        for (Comparable item : list) {
            root.insert(item);
        }

        System.out.println(root);
    }
}

publicstaticvoidmain（字符串[]args）{
整数[]整数项={1,7,8,2，-1，-10,100,12,32}；
String[]stringItems={“jungi”、“phil”、“bob”、“leslie”、“tyler”、“clarence”}；
可比[]可比列表={integerItems，stringItems}；
对于（可比[]列表：可比列表）{
BinarySearchTree root=新的BinarySearchTree（）；
用于（可比项目：清单）{
根。插入（项目）；
}
System.out.println（根）；
}
}

这会产生以下编译器错误：

BinarySearchTree.java:26: error: bad operand types for binary operator '<'
    } else if (v < value) {
                 ^
first type:  T
second type: T
where T is a type-variable:
  T extends Comparable declared in class BinarySearchTree
  BinarySearchTree.java:37: error: bad operand types for binary operator '<'
      } else if (v < value) {
                 ^
first type:  T
second type: T
where T is a type-variable:
  T extends Comparable declared in class BinarySearchTree
2 errors

---

BinarySearchTree.java:26:error:binary运算符的操作数类型不正确您不需要在运行时知道具体类型，泛型是在编译时应用的

因此，您可以在代码中执行以下操作：

public static void main(String[] args) {
    Integer[] integerItems = {1, 7, 8, 2, -1, -10, 100, 12, 32};
    String[] stringItems = {"jungi", "phil", "bob", "leslie", "tyler", "clarence"};
    Comparable[][] comparableLists = {integerItems, stringItems};

    for (Comparable[] list : comparableLists) {
        BinarySearchTree b = BinarySearchTree.class.newInstance();
        for (Object element : list) {
            b.add(element); // or whatever method you want to use
        }
    }
}

您现在只需要小心，不要使用错误的类型，因为编译器没有为您提供任何帮助的通用方法

看：

这就是对多种类型的对象使用公共接口的要点。使用
可比较的

    for (Comparable[] list : comparableLists) {
        BinarySearchTree<Comparable> tree = ...

for（可比[]列表：可比列表）{
二进制搜索树=。。。
不要使用原始类型！抱歉，对Java来说太陌生了。你是什么意思？你是什么意思？你可能可以用反射来实现，但获取类型并不容易。Java在这方面相当有限。@SotiriosDelimanolis在查看了你的链接后，我甚至不确定我在哪里使用了原始类型。你能解释一下吗？我不知道什么是原始类型e我正在这样做，或者说原始类型与这个特定问题有什么关系这是使用原始类型-非常危险。@OldCurmudgeon你在回答中使用了原始类型！不-
BinarySearchTree
不是原始类型-
BinarySearchTree b
是。@OldCurmudgeon
Comparable
是原始类型。@pbabcdefp-拍自己的额头！！-我的阿波罗ogies-its确实是原始的（严格来说，它是
可比的
），但在我的情况下，我的
树
变量不是原始类型，而这个答案中的
b
是原始类型。