Do Java arrays have a maximum size?

java arrays

213,014

Solution 1

Haven't seen the right answer, even though it's very easy to test.

In a recent HotSpot VM, the correct answer is Integer.MAX_VALUE - 5. Once you go beyond that:

public class Foo {
  public static void main(String[] args) {
    Object[] array = new Object[Integer.MAX_VALUE - 4];
  }
}

You get:

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

Solution 2

This is (of course) totally VM-dependent.

Browsing through the source code of OpenJDK 7 and 8 java.util.ArrayList, .Hashtable, .AbstractCollection, .PriorityQueue, and .Vector, you can see this claim being repeated:

/**
 * Some VMs reserve some header words in an array.
 * Attempts to allocate larger arrays may result in
 * OutOfMemoryError: Requested array size exceeds VM limit
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

which is added by Martin Buchholz (Google) on 2010-05-09; reviewed by Chris Hegarty (Oracle).

So, probably we can say that the maximum "safe" number would be 2 147 483 639 (Integer.MAX_VALUE - 8) and "attempts to allocate larger arrays may result in OutOfMemoryError".

(Yes, Buchholz's standalone claim does not include backing evidence, so this is a calculated appeal to authority. Even within OpenJDK itself, we can see code like return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; which shows that MAX_ARRAY_SIZE does not yet have a real use.)

Solution 3

There are actually two limits. One, the maximum element indexable for the array and, two, the amount of memory available to your application. Depending on the amount of memory available and the amount used by other data structures, you may hit the memory limit before you reach the maximum addressable array element.

Solution 4

Going by this article http://en.wikipedia.org/wiki/Criticism_of_Java#Large_arrays:

Java has been criticized for not supporting arrays of more than 2³¹−1 (about 2.1 billion) elements. This is a limitation of the language; the Java Language Specification, Section 10.4, states that:

Arrays must be indexed by int values... An attempt to access an array component with a long index value results in a compile-time error.

Supporting large arrays would also require changes to the JVM. This limitation manifests itself in areas such as collections being limited to 2 billion elements and the inability to memory map files larger than 2 GiB. Java also lacks true multidimensional arrays (contiguously allocated single blocks of memory accessed by a single indirection), which limits performance for scientific and technical computing.

Solution 5

Arrays are non-negative integer indexed , so maximum array size you can access would be Integer.MAX_VALUE. The other thing is how big array you can create. It depends on the maximum memory available to your JVM and the content type of the array. Each array element has it's size, example. byte = 1 byte, int = 4 bytes, Object reference = 4 bytes (on a 32 bit system)

So if you have 1 MB memory available on your machine, you could allocate an array of byte[1024 * 1024] or Object[256 * 1024].

Answering your question - You can allocate an array of size (maximum available memory / size of array item).

Summary - Theoretically the maximum size of an array will be Integer.MAX_VALUE. Practically it depends on how much memory your JVM has and how much of that has already been allocated to other objects.

View more solutions

213,014

Lizard

I am a PHP Web Developer

Updated on June 18, 2021

Comments

Lizard over 1 year

Is there a limit to the number of elements a Java array can contain? If so, what is it?
- maaartinus about 10 years
  
  You've accepted a wrong answer, just try to allocate such a long array (and no, I'm not running out of memory).
- Ciro Santilli OurBigBook.com almost 8 years
  
  Closely related: stackoverflow.com/questions/878309/…
- Ivan Mamontov over 7 years
  
  The right answer is stackoverflow.com/questions/31382531/…
Kevin Bourrillion over 12 years

I think the idea of downvotes makes no sense unless we are willing to downvote answers that are plain and simply wrong. Does the difference of five bytes actually matter in the real world, NO, of course not. But it concerns me that people are willing to give an answer "authoritatively" without even trying it to see if it really works. As for the memory limit, well, DUH. That's like if you asked me "how many grapes can you eat?" and I said "well, it depends on how many I have in the fridge at the time."
Pacerier about 11 years

Sry I'm not understanding your answer.. do you mean to say that the maximum is MAX_VALUE - 5 even if my machine has the required memory to create an int the size of MAX_VALUE ?
bestsss almost 11 years

@Pacerier, yes, the memory address index is 32bit and there is an object header+length, so they still need to be addressed by that 32bit index.
Taymon almost 11 years

Do you happen to know why it won't give you those five bytes? Is this necessarily something that always happens in Java, or could it just be related to your computer's memory or something?
maaartinus about 10 years

@Kevin Bourrillion: This seems to have changed, using Oracle 1.7.0_07 I can allocate up to MAX_VALUE-2 elements. This is independent of what I allocate, and I really wonder what can the VM use the two "things" for (the length doesn't fit in 2 bytes).
maaartinus about 10 years

@bestsss: I don't think so... there may be only 2 spare bytes (see my above comment) and the object header is much bigger. Actually, the JVM can use unsigned ints, so there must be some other reason.
John Smith about 10 years

@KevinBourrillion: Well the five bytes do actually matter in the real world, since you cannot even instance the array (independant of the objects in it).
bestsss about 10 years

@maaartinus, the object header is much bigger Object header is (usually) 8bytes+4bytes length. References take 4 bytes on 32bit systems.
sudo almost 9 years

Wait, it runs out of memory. What if you just give it more memory? I want to know about the maximum length without that restraint. In C and Objective C, when you get the array's length, it's represented as a long.
Tomáš Zato almost 9 years

Does this limit also apply on strings?
Has QUIT--Anony-Mousse over 8 years

@TomášZato the latest at Integer.MAX_VALUE+1, you will have an integer overflow. Array sizes in Java are int, not long; no matter what data type you store in your array, bytes or references. Strings are just Object references.
Tomáš Zato over 8 years

I'm not sure how to understand this - so does string happen to be encapsulated array of chars or not?
Alexey Ivanov almost 8 years

Java can't allocate array of size Integer.MAX_VALUE - 1, you'll get "java.lang.OutOfMemoryError: Requested array size exceeds VM limit". The maximum number of elements in JDK 6 and above is Integer.MAX_VALUE - 2 = 2 147 483 645.
Alexey Ivanov almost 8 years

The maximum number of elements in an array in JDK 6 and above is Integer.MAX_VALUE - 2 = 2 147 483 645. Java successfully allocates such an array if you run it with -Xmx13G. It fails with OutOfMemoryError: Java heap space if you pass -Xmx12G.
JohnWinter over 7 years

And why we need to add -8?
Bitcoin Cash - ADA enthusiast over 7 years

@Pacerier. Shouldn't this MAX_ARRAY_SIZE be applied only when you are using an ArrayList? That is different from using an array like int[] array = new int[some_value_here]; isn't it? Why can a constant defined in ArrayList be applied to a normal array (defined with [])? Are they the same behind the scenes?
Pacerier about 7 years

@Tiago, No, the code itself has got nothing to do with the maximum size of arrays. It's just a claim.
Pacerier about 7 years

@JohnWinter, The quote states "Some VMs reserve some header words in an array". So the -8 is due to the bytes the reserved header words would occupy.
kbolino almost 7 years

Java lacks the syntactic sugar for multidimensional arrays, but you can still "have" them with a little bit of multiplication (unless the total size of the array exceeded the aforementioned limit)
Dhruvam Gupta about 6 years

int arr[] = new int[1000000000]; gives OutOfMemoryError
Jim C almost 5 years

I guess that future readers may be interested to run eyes over stackoverflow.com/questions/48189656/…
dave_thompson_085 about 3 years

You're using a 32-bit JVM. Use a 64-bit JVM and the JVM limit will be close to 2^31. (You also need heap space available, which is not the default, and will be affected by your physical memory.)
avg almost 3 years

@AlexeyIvanov You mean an int array right? Testing in Eclipse Version: 2019-06 (4.12.0), jdk1.8.0_221, I got the same result for an int array, setting the options in a run configuration for the test class, although jvisualvm shows 8GB heap space allocated to the test process. For a boolean array I didn't need to set run config options for the test class with -Xmx1024m set in eclipse.ini, and jvisualvm shows 2GB heap space allocated to the test process.
Alexey Ivanov almost 3 years

@avg I don't remember; likely I was allocating an array of int. The required heap size depends on the JVM and chosen GC. Additionally, boolean is four times smaller than int, and it may be compressed to store 8 values in one byte.
Stefan Reich over 2 years

@kbolino It's true. I'm sure the scientific users are smart enough to make their own multi-dimensional arrays