Get object class and use as argument for generic constructor

Question

I'm sure this has been asked before but I am new to Java and unfamiliar with the exact terminology I'm looking for.

I have a BST class:

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

Then I wrote some tests for it:

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<>...
    }
}

I am confused at this step. How can I recover the types (String[], Integer[], etc.) from the list and use them as an argument? I want to have something like this:

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

One option I found here was just to list out all the possible supported types. This seems really silly because I don't know all the supported types. Maybe these types will change, etc. but I had it hard-coded.

How can I deal with this best?

EDIT:

So just to be a little more specific, here is the BST implementation:

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;
    }
}

If I use @OldCurmudgeon's suggestion the main() looks like this:

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);
    }
}

This produces the following compiler error:

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

Perhaps this is more helpful?

Sorry, too new to Java. What do you mean? How do you mean? lol — eatonphil, Mar 27 '15 at 14:33
http://stackoverflow.com/questions/2770321/what-is-a-raw-type-and-why-shouldnt-we-use-it — Sotirios Delimanolis, Mar 27 '15 at 14:34
You could probably do it with Reflection, but there's no easy way to get the type. Java is rather limited in that aspect. — blalasaadri, Mar 27 '15 at 14:37
@SotiriosDelimanolis After looking at your link, I'm not even sure where I'm using raw types. Could you explain a little? I am missing where I'm doing that or how raw types are relevant to this particular issue — eatonphil, Mar 27 '15 at 14:46
@eatonphil For example here: `BinarySearchTree`. You're using a raw `Comparable`. It should be `BinarySearchTree>`. — Tom, Mar 27 '15 at 14:50
Your compile error is because you cannot use `Comparable < Comparable` - use `Comparable.compareTo(other) < 0`. — OldCurmudgeon, Mar 27 '15 at 15:18
@eatonphil this is hands-on generics tutorial by one of authors: www.cs.rice.edu/~cork/312/Readings/GenericsTutorial.pdf — Victor Sorokin, Mar 27 '15 at 15:37

Victor Sorokin · Answer 1 · 2015-03-27T15:27:42.210

Generic method to the rescue!

Look:

class BinarySearchTree<T extends Comparable<T>> {
    void put(T item) {}
}

class Test {

    public static <T extends Comparable<T>> void putIntoATree(BinarySearchTree<T> tree, T[] items) {
        for (T item : items)
            tree.put(item);
    }

    public static void main(String[] args) {

        Integer[] integerItems = {1, 7, 8, 2, -1, -10, 100, 12, 32};
        BinarySearchTree<Integer> integerTree = new BinarySearchTree<>();
        putIntoATree(integerTree, integerItems);

        String[] stringItems = {"jungi", "phil", "bob", "leslie", "tyler", "clarence"};
        BinarySearchTree<String> stringTree = new BinarySearchTree<>();
        putIntoATree(stringTree, stringItems);

    }

}

Presence of arrays holding generified types, as in your example, usually forces a cast somewhere (or leaves 'unchecked' warning). That's why I've avoided using an array in my example.

One way to eliminate a cast and make code type-safe is to wrap array into a generic class which will make javac happy:

class BinarySearchTree<T extends Comparable<T>> {
    void put(T item) {}
}

class Test {

    public static <T extends Comparable<T>> void putIntoATree(BinarySearchTree<T> tree, T[] items) {
        for (T item : items)
            tree.put(item);
    }

    private static class ArrayAndATree<T extends Comparable<T>> {
        final T[] contents;
        final BinarySearchTree<T> aTree;

        private ArrayAndATree(T[] contents) {
            this.contents = contents;
            aTree = new BinarySearchTree<>();
        }
    }
    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"};

        ArrayAndATree<Integer> integerArrayAndATree = new ArrayAndATree<>(integerItems);
        ArrayAndATree<String> stringArrayAndATree = new ArrayAndATree<>(stringItems);

        ArrayAndATree<?> taggedArrays[] = {integerArrayAndATree, stringArrayAndATree};
        for (ArrayAndATree<?> a : taggedArrays) {
            putIntoATree(a.aTree, a.contents);
            process(a);
        }
    }

    private static <T extends Comparable<T>> void process(ArrayAndATree<T> a) {
        putIntoATree(a.aTree, a.contents);
    }
}

score 0 · Answer 2 · answered Mar 27 '15 at 14:55

0

This is the point of using a common interface to multiple types of objects. Use Comparable.

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

answered Mar 27 '15 at 14:55

OldCurmudgeon

64,482
16
119
213

score -1 · Answer 3 · answered Mar 27 '15 at 14:50

-1

You don't need to know the concrete type at runtime, generics are applied at compile.

So in your code you can do this:

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
        }
    }
}

You just need to be careful to not use the wrong type now as the compiler isn't giving you any guidance

answered Mar 27 '15 at 14:50

tddmonkey

20,798
10
58
67

This is using raw types - very dangerous. – OldCurmudgeon Mar 27 '15 at 14:56
@OldCurmudgeon You used raw types in your answer! – Paul Boddington Mar 27 '15 at 14:58
Nope - `BinarySearchTree` is not a raw type - `BinarySearchTree b` is. – OldCurmudgeon Mar 27 '15 at 14:59
@OldCurmudgeon `Comparable` is a raw type. – Paul Boddington Mar 27 '15 at 15:00
Nope - `Comparable is an interface`. See [here](http://stackoverflow.com/questions/2770321/what-is-a-raw-type-and-why-shouldnt-we-use-it) for a discussion. – OldCurmudgeon Mar 27 '15 at 15:06
@OldCurmudgeon It is both an interface and a raw type. Just like `List`. – Paul Boddington Mar 27 '15 at 15:12
1

@pbabcdefp - *Slaps own forehead!!* - My apologies - its is indeed raw (in the strictest sense of it being `Comparable`) but in my case my `tree` variable is not of raw type while the `b` in this answer *is*. – OldCurmudgeon Mar 27 '15 at 15:16
Dangerous possibly, but this was explained in the answer – tddmonkey Mar 27 '15 at 16:03

Get object class and use as argument for generic constructor

3 Answers3