Java / P5：如何声明包含FloatLists的Arraylist数组？

Question

If I can declare an Array of FloatLists: FloatList [][] values = new FloatList[3][3];

Why doesn't it work to declare an Array of ArrayLists holding FloatLists like this: ArrayList<FloatList> [][] values = new ArrayList<FloatList>() [3][3]; ? OR EVEN: ArrayList<FloatList> [][] values = new ArrayList<FloatList> [3][3]();

How can this be achieved? Will it be hard to refer to the floats buried deep under its crusty texture?

Answer 1

Work from the inner-most type to the outer-most type. You start with FloatList :

FloatList

Then wrap that in an ArrayList :

ArrayList<FloatList>

Then you want an array of that:

ArrayList<FloatList>[]

Or a 2D array:

ArrayList<FloatList>[][]

That gives you the type for the declaration, but then you have to initialize the variable by giving it a value. Start with the array by giving it a size:

ArrayList<FloatList>[] array = new ArrayList[10];

This gives you an array of ArrayList<FloatList> objects, but they start out as null . To give them a value, you'd loop over every index in the array and use the new keyword to set the value of the index to an instance of ArrayList<FloatList> :

for(int i = 0; i < array.length; i++){
   array[i] = new ArrayList<FloatList>();
}

For a 2D array, you'd use the same logic, just in a nested for loop.

Then to add a FloatList to an ArrayList at a specific index of the array, you'd do this:

array[i].add(new FloatList());

Finally, to add a float to a FloatList in an ArrayList at an index in the array, you'd do this:

array[x].get(y).append(0.5);

And to get a float out of an index in the FloatList in an ArrayList at an index in the array, you'd do this:

float f = array[x].get(y).get(z);

Putting it all together, it looks like this:

ArrayList<FloatList>[] array = new ArrayList[10];

for(int i = 0; i < array.length; i++){
   array[i] = new ArrayList<FloatList>();
}

array[1].add(new FloatList());

array[1].get(0).append(0.25);
array[1].get(0).append(0.5);
array[1].get(0).append(0.75);

float f = array[1].get(0).get(2);

println(f);

Answer 2

ArrayList<FloatList> [][] values = new ArrayList[3][3];

Basically, you're declaring that you want an object that is a 3D array of ArrayList s, and not generating actual ArrayList objects.

Afterwards, you have to instantiate each of them, so for example:

values[0][0] = new ArrayList<>();

And so on.

Answer 3

It doesn't work because of the way the JVM provides Generics. Generics in Java is a front-end compiler feature that becomes raw type usages and casts at execution time.

What is the compiler doing when I use generics?

Here's a terribly-contrived example. Let's say I want to create a List<String> to store command line arguments that I will later use to kick off a new process with, like so:

List<String> cmd = new ArrayList<>();
cmd.add("java");
cmd.add("-jar");
cmd.add("path/to/my.jar");
...
String args = cmd.get(0)+" "+cmd.get(1)+" "+cmd.get(2);

At compile time, the compiler will check to make sure that I am using the String type every time I use a generic List method via cmd and throw an error if I try to use instances of an incompatible type. However, there's a little thing called erasure that happens during compilation, before execution. Effectively, under the hood, the compiler converts the code above into something like this:

List cmd = new ArrayList();
cmd.add("java");
cmd.add("-jar");
cmd.add("path/to/my.jar");
...
String args = (String)cmd.get(0)+" "+(String)cmd.get(1)+" "+(String)cmd.get(2);

So why doesn't my generic array code compile?

In your example, you wanted to create an array of a generic type, like so:

ArrayList<FloatList>[][] array = new ArrayList<FloatList>[n][m]; //Doesn't compile? What gives?

The problem is, because of type erasure, the ArrayList<FloatList> class type doesn't really exist, and now you've asked the JVM to create a 2-dimensional array of that non-existent type.

Okay, so what's the alternative?

Well ... it isn't pretty, but you could do something like this:

class ArrayListOfFloatList extends ArrayList<FloatList>{
    ...
}

//Somewhere else in your code:
ArrayListOfFloatList[][] myArray = new ArrayListOfFloatList[n][m];
//This will compile because ArrayListOfFloatList is a real class.

The only other way around this would be to not use arrays. Ugly, perhaps, but it's unfortunately a limitation of how Java is currently implemented.