# Array Length inJava

Sven Woltmann
Last update: April 14, 2024

• How to find out the length of an array in Java,
• How to define the length of an array in Java,
• How much memory space an array occupies on the heap,
• And what the maximum size of an array is in Java.

We consider both one-dimensional and 2D arrays.

## How to Find the Length of an Array in Java?

Let’s assume we get a Java array as follows:

``String[] names = getNames();`Code language: Java (java)`

Then we find out the length of this array, i.e., the number of entries in it, as follows:

``int numberOfCustomers = customers.length;`Code language: Java (java)`

### How to Get the Length of a 2D Array in Java?

With a two-dimensional array, things get a little more complicated. In Java, a two-dimensional array is an array of arrays. A matrix of height two and width three would be represented like this:

We can now determine the height and width as follows:

``````int[][] intMatrix = getMatrix();
int height = intMatrix.length;
int width = intMatrix[0].length;```Code language: Java (java)```

The height is the length of the array (i.e., the number of rows the matrix contains), and the width is the length of the first row.

Please note, however, that with a two-dimensional array in Java, all sub-arrays do not necessarily have to be the same length. A 2D array could also look like this:

Here, we could calculate statistics on the line lengths:

``````int[][] twoDimensionalArray = {{2, 3, 6}, {4, 5, 1, 9, 7}};
IntSummaryStatistics statistics =
Arrays.stream(twoDimensionalArray).mapToInt(row -> row.length).summaryStatistics();
System.out.println(statistics);
```Code language: Java (java)```

The following result would be output for the example matrix shown above:

``IntSummaryStatistics{count=2, sum=8, min=3, average=4.000000, max=5}`Code language: plaintext (plaintext)`

We have two lines, the sum of the lengths is 8 (that's right: 5 plus 3), the minimum is 3, the average size is 4, and the maximum is 5.

## How to Set the Array Length in Java?

The length of an array is defined when it is initialized. The following code, for example, creates a string array of size four:

``String[] fruits = {"jujube", "apple", "boysenberry", "cherry"};`Code language: Java (java)`

We can also define a string array of the same size as follows:

``String[] fruits = new String[4];`Code language: Java (java)`

However, this array does not yet contain any values; is initialized with `null` at each position. You can learn about initializing strings in the article How to Initialize Arrays in Java.

After initialization, we can no longer change the array length.

### How To Set the Length of a 2D Array in Java?

You can also define the length of a 2D array in the two ways shown above – i.e., with predefined values:

``int[][] twoDimensionalArray = {{2, 3, 6}, {4, 5, 1, 9, 7}}`Code language: Java (java)`

This code creates the two-dimensional array shown above with sub-arrays of different lengths.

And secondly, with default values (0 in the case of the type `int`):

``int[][] twoDimensionalArray = new int[2][3];`Code language: Java (java)`

This code creates the following array:

You can learn more about initializing 2D arrays in the article How to Initialize Arrays in Java.

## How Much Memory Does a Java Array Take Up?

In the following, we look at the memory layout for compressed oops, i.e., compressed pointers, the standard setting on 64-bit machines as of Java 22 (before the header is further compressed by Project Lilliput).

An array is an object in Java; therefore, like any other object, it has a 12-byte object header. This is followed by four bytes in which the length of the array is stored. This is followed by the actual elements of the array in sequential order.

For example, the `int` array [6, 1, 1, 5, 7] is stored in the memory as follows:

The last four bytes marked with “padding” are not really part of the array but cannot be used in any other way either, as objects in the Java heap are stored at memory addresses divisible by eight when using compressed oops. This is because, with 32 bits, we can address not just 232 bytes, i.e. 4 GB, but eight times as many, i.e. 32 GB.

Elements in primitive arrays each occupy the following memory space:

• `boolean` and `byte`: 1 byte each
• `short` and `char`: 2 bytes each
• `int` and `float`: 4 bytes each
• `long` and `double`: 8 bytes each

With `short` instead of `int` values, the array would have the following layout:

And with `byte` elements, it would have the following layout:

We can calculate the total size of an array as follows:

Total size = align(12 bytes + 4 bytes + number of elements × size of element type in bytes)

The align function rounds the result up to the next value divisible by eight so that the result contains the “wasted” space.

This results in the following size for the `int` array with five elements:

Total size = align(12 bytes + 4 bytes + 5 × 4 bytes)
= align(36 bytes)
= 40 bytes

If we were to store the same five elements in a `long` array, it would have the following size:

Total size = align(12 bytes + 4 bytes + 5 × 8 bytes)
= align(56 bytes)
= 56 bytes

With object arrays, it is not the objects themselves that are stored in the array but the references to the objects. The following graphic shows the memory layout of the string array shown above:

I have not shown the object layout of the strings themselves here, as this article is primarily about arrays, not strings. The strings also have a header, several fields, and a reference to a `byte` array, which in turn contains a header, a length field, and the actual characters of the string.

### How Much Memory Does a 2D Array Take up in Java?

As you have seen above, a two-dimensional array is actually an array of arrays. Therefore, we must add the memory space of the outer array and that of all the inner arrays.

The array from the example shown above has the following memory layout:

We can calculate the total size of this 2D array as follows:

Total size = align(12 bytes + 4 bytes + number of lines × 4 bytes)
+ number of rows × align(12 bytes + 4 bytes + number of columns × size of element type in bytes)

For the example matrix with two rows and three columns, the following results:

Total size = align(12 bytes + 4 bytes + 2 x 4 bytes) + 2 × align(12 bytes + 4 bytes + 3 × 4 bytes)
= align(24 bytes) + 2 × align(28 bytes)
= 24 bytes + 2 × 32 bytes
= 88 bytes

## Max Array Size in Java

Java arrays use an `int` for the index, meaning the theoretical upper limit is `Integer.MAX_VALUE`, i.e., 2,147,483,647 elements.

According to the formula above, an `int` array of this size would occupy just over 8 GB. That shouldn’t be a problem for most modern computers.

When I try to create an array of this size – no matter which primitive type I use – I get the following error:

Exception in thread "main" java.lang.OutOfMemoryError: Requested array size exceeds VM limit

Only when I reduce the size by two to 2,147,483,645, does it work – and again with all primitive data types, even with `long`. The limit, therefore, has nothing to do with the available memory but is determined by the VM.

The following table shows the maximum array size for all primitive types – both in terms of the number of elements and the heap memory occupied on my VM:

### Max Size of a 2D Array in Java

The upper limit described in the previous chapter applies to each array dimension. Theoretically, the following sizes would, therefore, be possible with two-dimensional arrays:

In this case, the size is not limited by the VM but by the available memory or the memory that the garbage collector can manage (e.g., 16 TB for the ZGC).

## Conclusion

We can find the length of an array using `array.length`. We can only set the length of an array when it is created; we cannot change it afterward.

With compressed oops, arrays have a 12-byte object header and a 4-byte length field, followed by the actual data (1 byte per `byte`/`boolean`, 2 bytes per `short`/`char`, 4 bytes per `int`/`float` or object reference, and 8 bytes per `long`/`double`).

An array can contain a maximum of `Integer.MAX_VALUE - 2` elements (on most VMs), regardless of the type of array elements.

If you liked the article, share it using one of the share buttons at the end or leave me a comment.