Take the 2-minute tour ×

As far as I understand (from answers such as this), java has no native multi-dimensional continuous memory arrays (unlike C#, for example).

While the jagged array syntax (arrays of arrays) might be good for most applications, I would still like to know what's the best practice if you do want the raw efficiency of a continuous-memory array (avoiding unneeded memory reads)

I could of course use a single-dimensional array that maps to a 2D one, but I prefer something more structured.

share|improve this question
I feel like you are micro optimizing. Mapping a 1d array to a 2d array only removes 1 array lookup. I can't imagine it will save you much/any time. –  jjnguy Feb 10 '11 at 15:37
If you need every bit of performance, you may be better suited using C or C++. –  helpermethod Feb 10 '11 at 15:44
In what circumstances do you think that having each row of a two dimensional array being contiguous with the next in memory be significantly more efficient than java's normal arrray of arrays? –  Highland Mark Feb 10 '11 at 15:45
I'm not saying it's a critical optimization, but it would be nice to know what the best practice is. –  ripper234 Feb 10 '11 at 15:53

5 Answers 5

it's not difficult to do it manually:

int[] matrix = new int[ROWS * COLS];

int x_i_j = matrix[ i*COLS + j ];

now, is it really faster than java's multi dimension array?

int x_i_j = matrix[i][j];

for random access, maybe. for continuous access, probably not - matrix[i] is almost certainly in L1 cache, if not in register cache. in best scenario, matrix[i][j] requires one addition and one memory read; while matrix[i*COLS + j] may cost 2 additions, one multiply, one memory read. but who's counting?

share|improve this answer
With a single array, however, you would only do bounds-checking once instead of twice. –  Eric Giguere Feb 10 '11 at 16:01
if optimization caches matrix[i], it's one less bound check. –  irreputable Feb 10 '11 at 17:09

It depends on your access pattern. Using this simple program, comparing an int[][] with a 2D mapped over a 1D int[] array treated as a matrix, a native Java 2D matrix is:

  1. 25% faster when the row is on the cache, ie: accessing by rows:
  2. 100% slower when the row is not in the cache, ie: accessing by colums:


// Case #1
        // Access item[y][x]

// Case #2
        // Access item[y][x]

The 1D matrix is calculated as:

public int get(int x, int y) {
    return this.m[y * width + x];
share|improve this answer
nice. so vm optimization isn't as smart as I thought. –  irreputable Feb 10 '11 at 17:12
On the contrary, JIT optimizes method calls more than just inlining them. Calling the get(x, y) method is faster than accesing the matrix from the outside directly. –  vz0 Feb 10 '11 at 18:10

If you really want more structure with a continuous-memory array, wrap it in an object.

public class My2dArray<T> {

  int sizeX;

  private T[] items;

  public My2dArray(int x, int y) {
    sizeX = x;
    items = new T[x*y];

  public T elementAt(int x, int y) {
    return items[x+y*sizeX];


Not a perfect solution, and you probably already know it. So consider this confirmation of what you suspected to be true.

Java only provides certain constructs for organizing code, so eventually you'll have to reach for a class or interface. Since this also requires specific operations, you need a class.

The performance impacts include creating a JVM stack frame for each array access, and it would be ideal to avoid such a thing; however, a JVM stack frame is how the JVM implements it's scoping. Code organization requires appropriate scoping, so there's not really a way around that performance hit that I can imagine (without violating the spirit of "everything is an object").

share|improve this answer
You could also generalize and drop the "2D" and put the dimensions as a var-arg argument to the constructor (and let the elementAt take a var-arg for the indices) –  aioobe Feb 10 '11 at 15:48
True, but the example demonstrates the key idea. Odds are good he has a specific dimensional array in mind. –  Edwin Buck Feb 10 '11 at 15:53

If you cannot live without C constructs, there's always JNI.

Or you could develop your own Java-derived language (and VM and optimizing JIT compiler) that has a syntax for multidimensional continuous-memory arrays.

share|improve this answer

Sample implementation, without a compiler. This is basically what C/C++ do behind the scenes when you access multidimensional arrays. You'll have to further define accessor behaviour when less than the actual dimensions are specified & so on. Overhead will be minimal and could be optimized further, but thats microoptimizing imho. Also, you never actually know what goes on under the hood after JIT kicks in.

class MultiDimentionalArray<T> {
//disclaimer: written within SO editor, might contain errors
    private T[] data;
    private int[] dimensions; //holds each dimensions' size

    public MultiDimensionalArray(int... dims) {
        dimensions = Arrays.copyOf(dims, dims.length);
        int size = 1;
        for(int dim : dims)
            size *= dim;
        data = new T[size];

   public T access(int... dims) {
       int idx = 1;
       for(int i = 0; i < dims.length)
            idx += dims[i] * dimensions[i]; //size * offset
       return data[idx];
share|improve this answer

Your Answer


