更有效，更紧凑的方法是：大量的链表变量集或包含每个变量的二维数组列表？

Question

I want to create a large matrix (n by n) where each element corresponds to a LinkedList (of certain objects).

I can either

1. Create the n*n individual linked lists and name them with the help of eval() within a loop that iterates through both dimensions (or something similar), so that in the end I'll have LinkedList_1_1, LinkedList_1_2 etc. Each one has a unique variable name. Basically, skipping the matrix altogether.

2. Create an ArrayList of ArrayLists and then push into each element a linked list.

Please recommend me a method if I want to conserve time & space, and ease-of-access in my later code, when I want to reference individual LinkedLists. Ease-of-acess will be poor with Method 1, as I'll have to use eval whenever I want to access a particular linked list.

My gut-feeling tells me Method 2 is the best approach, but how exactly do I form my initializations?

Answer 1

As you know the sizes to start with, why don't you just use an array? Unfortunately Java generics prevents the array element itself from being a concrete generic type, but you can use a wildcard:

LinkedList<?>[][] lists = new LinkedList<?>[n][n];

Or slightly more efficient in memory, just a single array:

LinkedList<?>[] lists = new LinkedList<?>[n * n];

// Then for access...
lists[y * n + x] = ...;

Then you'd need to cast on each access - using @SuppressWarnings given that you know it will always work (assuming you encapsulate it appropriately). I'd put that in a single place:

@SuppressWarnings("unchecked")
private LinkedList<Foo> getList(int x, int y) {
    if (lists[y][x] == null) {
        lists[y][x] = new LinkedList<Foo>();
    }
    // Cast won't actually have any effect at execution time. It's
    // just to tell the compiler we know what we're doing.
    return (LinkedList<Foo>) lists[y][x];
}

Of course in both cases you'd then need to populate the arrays with empty linked lists if you needed to. (If several of the linked lists never end up having any nodes, you may wish to consider only populating them lazily.)

I would certainly not generate a class with hundreds of variables. It would make programmatic access to the lists very painful, and basically be a bad idea in any number of ways.