Lazy loading an interface in Java

Question

I'm trying to create a lazy loading method using Java Lists that takes in an index, adds elements to the List until the index is valid, and returns the value at that index.

For example, say I have a List like this [0, 1, 2, 3]. If I call my method with it and pass in index 1, it should return 1 without changing the List in any way. If I call my method with it and pass in index 5, it should return 0 (the default Integer value) and my List should now look like this [0, 1, 2, 3, 0, 0].

It seems pretty simple to implement at first, but I run into problems when I try to pass in Lists like a List<List<String>>. I know that you can't instantiate a list, so I try to make an ArrayList, but it doesn't work.

Here's the current incarnation of my method

protected <T> T getOrCreateAt(int index, List<T> list, Class<T> elementClass) {
    while (list.size() < index + 1) {
        try {
            list.add(elementClass.newInstance());
        } catch (InstantiationException e) {
            e.printStackTrace();
            System.exit(1);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    return list.get(index);
}

Here's one place where I call it

List<List<String>> solutionText = new ArrayList<List<String>>();

for (Node node : solution) {
    List<String> row = getOrCreateAt(node.rowNo, solutionText, ArrayList.class);
    getOrCreateAt(node.colNo, row, String.class);
    row.set(node.colNo, String.valueOf(node.cellNo));
}

The second call to getOrCreateAt works, but the first one doesn't compile.

How do I get my lazy loading method to work on interfaces and abstract classes?

Answer 1

I understand the answer to this question to mean this cannot be done by simple means. A somewhat unsatisfying solution: Make the parameter elementClass non-parameterised:

static <T> T getOrCreateAt(int index, List<T> list, Class<?> elementClass) {
    while (list.size() < index + 1) {
        try {
            list.add((T) elementClass.newInstance());
            // ...

You will get a compiler warning (unchecked cast) on the cast. And indeed you will unfortunately lose type safety this way.

Answer 2

A pattern I've followed in the past such factory-like behavior is accomplished through anonymous classes.

interface Factory<T> {
    T newInstance() throws InstantiationException, IllegalAccessException;
}

and then the implementations you need

Factory<List<String>> arrayListFactory = new Factory<List<String>>() {
    @Override
    public List<String> newInstance() throws InstantiationException, IllegalAccessException {
        return new ArrayList<String>();
    }
};
Factory<String> stringFactory = new Factory<String>() {
    @Override
    public String newInstance() throws InstantiationException, IllegalAccessException {
        return String.class.newInstance();
    }
};

and of course change your method to accept the factory thing instead of a class.

protected static <T> T getOrCreateAt(int index, List<T> list, Factory<T> factory) {
    while (list.size() < index + 1) {
        try {
            list.add(factory.newInstance());

so the usage would look like

for (Node node : solution) {
    List<String> row = TestThing.getOrCreateAt(node.rowNo, solutionText, arrayListFactory);
    getOrCreateAt(node.colNo, row, stringFactory);
    row.set(node.colNo, String.valueOf(node.cellNo));
}

If I didn't need this outside of one file, I'd probably stick them all in that source file as inner members.

Answer 3

Have you tried

protected <T> T getOrCreateAt(int index, List<T> list, Class<? extends T> elementClass) {
    // ...
}

List<String> row = getOrCreateAt(node.rowNo, solutionText, ( Class< ArrayList< String > > )solutionText.getClass());

? ArrayList< String > is a subclass of List< String >, so Class< ArrayList > is a subclass of Class< ? extends List > (but not Class< List >). The cast and getClass() call is necessary because ArrayList.class is not a Class< ? extends List< String > >.

Answer 4

Subclass ArrayList (remember generics) and override the set method to get the behaviour you describe. This code shows how if nullis to be the value for unassigned elements.

public T set(int index, T arg1) {
    while (index >= size()) {
        add(null);
    }
    return super.set(index, arg1);
}

You can then use the list as you want with the new behavior just by using a different new when allocation the list.

I would guess you can do this in a single screenfull of code.