Use array or vector ?

Question

I need to store data into a 3D array i.e. abc[128][128][128]. Every item of the array is an object.
My problem is, if i use 3D array to store the data directly, it is too memory costing and always return OutOfMemoryError!!! Also terribly slow !
Is it better to use vector of vector instead of 3D array? I mean put the 128 objects into a single array and then put 128 single arrays into a vector, lastly put 128 vectors into a new vector.
Or otherwise, who has any other good suggestions to store these 128*128*128 objects?

Answer 1

However, that's small compared to the number ofdistinct objects in that space -- 128^3. So the number
of objects taken up by the arrays or vectors, is less
than 1% of the number of objects in the 3D space
defined by the arrays or vectors.
Sorry, I don't get what you mean ;)
Yes, it is 1% of the number of objects in the 3D
space, but you haven't calculate the 4 bytes int value
used by the int value itself.We're not talking about ints though, are we? The question was about a 3D space of objects.
So, if let say array Object definition uses 2 bytes,
then the RAM needed will be:
Object definition + int values
((128^2 + 128 + 1) * 2) + ((128^3) * 4)
if you create int[128^3], you will only create:
128^3 * 4Given that problem statement, the array object definitions take up 33026 bytes, whereas the int values take up 8388608. So the memory used by the array object definitions is still just 1% of the memory used. By switching to a 1D array of length 128^3, you're saving less than 1% of the memory. The 33026 bytes isn't the problem here.
(((128^2 + 128 + 1) * 2) + ((128^3) * 4)) is a much bigger number than ((128^2 + 128 + 1) * 2).
Just (128^3 * 4) is a much bigger number than ((128^2 + 128 + 1) * 2).
But anyway that's not the problem statement anyway. There are 128^3 potential objects created in the heap. That's going to be a lot more than the arrays or vectors used to reference them.
This is why I think the best solution is to look at the data and see if a better approach can be taken than just using 128^3 buckets.
Another slow but possible solution is using HashMap.
To check coordinate 33, 75, 109, you can use:
map.get(new Integer(33*75*109)] and hope Java garbage
collector runs pretty fast.I wouldn't advise that, because that would cause conflicts between objects at 33,75,109 and 75,33,109, etc. There would be 3! = 6 possible conflicts. If you want to turn the 3D index into a flat 1D index, then multiply each coordinate by a constant to put each into its own range, e.g., (33,75,109)'s 1D index would be (33 * (128^2)) + (75 * 128) + 109.
Hopefully that's less than the maximum int value. It may not be.
This solution works fine only if in vast 128*128*128,
only few hundreds coordinate x,y,z which actually have
a value. This way you can store the value only if
needed.Yes, exactly, if the domain data is sparse, a different approach like this would work better than defining 128^3 data buckets.
If the data is sparse enough, it might be easier to define a 3DCoordinate object to use as the index into the hashtable, than programmatically creating a 1D index.