In diesem Artikel erfährst du:
- wie man die Länge eines Arrays in Java herausfindet,
- wie man die Länge eines Arrays in Java festlegt,
- wie viel Speicherplatz ein Array auf dem Heap belegt
- und was die maximale Größe eines Arrays in Java ist.
Wir betrachten dabei sowohl eindimensionale als auch 2D-Arrays.
Wie findet man die Länge eines Arrays in Java?
Nehmen wir an, wir erhalten wie folgt ein Java-Array:
String[] names = getNames();Dann finden wir die Länge dieses Arrays, also die Anzahl von Einträgen darin, wie folgt heraus:
int numberOfNames = names.length;Beachte: length ist bei Arrays ein Feld, kein Methodenaufruf – anders als String.length() oder List.size(). Schreibst du names.length(), meldet der Compiler einen Fehler.
Liegt dir ein Array nur als Object vor, etwa in generischem Code, dann liefert java.lang.reflect.Array.getLength(array) seine Länge.
Wie findet man die Länge eines 2D-Arrays in Java?
Bei einem zweidimensionalen Array wird es etwas komplizierter. Ein zweidimensionales Array ist in Java ein Array von Arrays. Eine Matrix der Höhe zwei und Breite drei würde etwa so repräsentiert werden:
Höhe und Breite könnten wir jetzt wie folgt bestimmen:
int[][] intMatrix = getMatrix();
int height = intMatrix.length;
int width = intMatrix[0].length;Die Höhe ist die Länge des Arrays (also die Anzahl an Zeilen, die die Matrix enthält), und die Breite bestimmen wir als die Länge der ersten Zeile.
Hat die Matrix keine Zeilen, wirft intMatrix[0] eine ArrayIndexOutOfBoundsException – prüfe in dem Fall vorher, ob height größer als 0 ist.
Beachte aber bitte, dass bei einem zweidimensionalen Array in Java nicht zwingend alle Unter-Arrays gleich lang sein müssen. Ein 2D-Array könnte auch so aussehen:
Hier könnten wir Statistiken über die Zeilenlängen berechnen lassen:
int[][] twoDimensionalArray = {{2, 3, 6}, {4, 5, 1, 9, 7}};
IntSummaryStatistics statistics =
Arrays.stream(twoDimensionalArray)
.mapToInt(row -> row.length)
.summaryStatistics();
System.out.println(statistics);Für die oben gezeigte Beispiel-Matrix würde folgendes Ergebnis ausgegeben werden:
IntSummaryStatistics{count=2, sum=8, min=3, average=4.000000, max=5}Wir haben zwei Zeilen, die Summe der Längen ist 8 (stimmt: 5 plus 3), das Minimum ist 3, die durchschnittliche Länge ist 4, und das Maximum ist 5.
Übrigens: IntSummaryStatistics.toString() formatiert den Durchschnitt mit String.format() und damit abhängig von der Locale – auf einem System mit deutscher Spracheinstellung steht dort average=4,000000.
Wie legt man die Länge eines Arrays in Java fest?
Die Länge eines Arrays wird bei dessen Initialisierung festgelegt. Der folgende Code beispielsweise erzeugt ein String-Array der Größe vier:
String[] fruits = {"jujube", "apple", "boysenberry", "cherry"};Ein String-Array derselben Größe können wir auch wie folgt festlegen:
String[] fruits = new String[4];Dieses Array enthält dann allerdings noch keine Werte, sondern wird mit null an jeder Position initialisiert. Alles über die Initialisierung von Arrays erfährst du im Artikel Arrays in Java initialisieren.
Nach der Initialisierung kann die Länge eines Arrays nicht mehr verändert werden.
Wie legt man die Länge eines 2D-Arrays in Java fest?
Auch bei einem 2D-Array kannst du die Länge auf die zwei oben gezeigten Arten festlegen – also zum einen mit vorgegebenen Werten:
int[][] twoDimensionalArray = {{2, 3, 6}, {4, 5, 1, 9, 7}};Dies erzeugt das oben gezeigte zweidimensionale Array mit unterschiedlich langen Unter-Arrays.
Und zum anderen mit Default-Werten (0 im Fall des Typs int):
int[][] twoDimensionalArray = new int[2][3];Dies erzeugt das folgende Array:
Mehr über die Initialisierung von 2D-Arrays erfährst du im Artikel Arrays in Java initialisieren.
Wie viel Speicherplatz belegt ein Java-Array?
Wir betrachten im Folgenden das Speicherlayout mit Compact Object Headers, die seit Java 27 standardmäßig aktiv sind, und mit Compressed Oops, also komprimierten Objektreferenzen – der Standardeinstellung auf 64-Bit-Maschinen bei einem Heap bis 32 GB.
Ein Array ist in Java ein Objekt und hat damit – wie jedes andere Objekt auch – einen 8-Byte-Objekt-Header. Darauf folgen vier Bytes, in denen die Länge des Arrays hinterlegt ist. Ab Byte 12 folgen die Elemente des Arrays in sequenzieller Anordnung.
Die folgende Grafik zeigt, wie das int-Array [6, 1, 1, 5, 7] bis Java 26 und wie es seit Java 27 im Speicher liegt:
Du siehst: Der kleinere Header spart bei diesem Array acht Bytes – aus 40 Bytes werden 32. Bis Java 26 endeten die Elemente bei Byte 36, und die letzten vier Bytes waren Padding – Füllbytes, die nicht Teil des Arrays sind, aber auch nicht anderweitig verwendet werden können; warum das so ist, steht in der folgenden Hinweisbox. Seit Java 27 füllen die fünf int-Werte den Platz bis Byte 32 genau aus.
Elemente in primitiven Arrays belegen jeweils den folgenden Speicherplatz:
booleanundbyte: je 1 Byteshortundchar: je 2 Bytesintundfloat: je 4 Byteslongunddouble: je 8 Bytes
Mit short- statt int-Werten hätte das Array folgendes Layout:
Und mit byte-Elementen hätte es folgendes Layout:
Bei long- und double-Elementen kommt eine Besonderheit hinzu: 8-Byte-Werte müssen an durch acht teilbaren Adressen liegen, damit die CPU sie in einem einzigen Speicherzugriff lesen und schreiben kann – nicht ausgerichtete 8-Byte-Zugriffe sind auf manchen Prozessorarchitekturen langsamer und auf anderen gar nicht erlaubt. Die Elemente beginnen deshalb nicht bei Byte 12, sondern erst bei Byte 16 – die vier Bytes dazwischen bleiben ungenutzt.
Die Gesamtgröße eines Arrays können wir wie folgt ausrechnen:
Gesamtgröße = align(8 Bytes + 4 Bytes + Anzahl Elemente × Größe des Elementtyps in Bytes)
Die align-Funktion rundet das Ergebnis auf den nächsten durch acht teilbaren Wert auf, so dass das Ergebnis das Padding beinhaltet. Bei long- und double-Arrays beginnen die Elemente bei Byte 16; dort lautet die Formel Gesamtgröße = 16 Bytes + Anzahl Elemente × 8 Bytes – ein Aufrunden ist nicht nötig, da das Ergebnis immer durch acht teilbar ist.
Für das int-Array mit fünf Elementen ergibt sich also folgende Größe:
Gesamtgröße = align(8 Bytes + 4 Bytes + 5 × 4 Bytes)
= align(32 Bytes)
= 32 Bytes
Würden wir die gleichen fünf Elemente in einem long-Array speichern, hätte es folgende Größe:
Gesamtgröße = 16 Bytes + 5 × 8 Bytes
= 56 Bytes
Bei Objekt-Arrays werden nicht die Objekte selbst im Array abgelegt, sondern die Referenzen auf die Objekte – bei Compressed Oops je 4 Bytes. Die folgende Grafik zeigt das Speicherlayout des oben gezeigten String-Arrays:
Das Objekt-Layout der Strings selbst habe ich hier nicht dargestellt, da es in diesem Artikel primär um Arrays geht, nicht um Strings. Die Strings selbst haben auch wieder einen Header, mehrere Felder und eine Referenz auf ein byte-Array, das wiederum einen Header enthält, ein Längenfeld und die Zeichen des Strings.
Wie viel Speicherplatz belegt ein 2D-Array in Java?
Ein zweidimensionales Array ist, wie du oben gesehen hast, ein Array von Arrays. Wir müssen also den Speicherplatz des äußeren Arrays und den aller inneren Arrays addieren.
Die Matrix mit zwei Zeilen und drei Spalten aus dem ersten 2D-Beispiel hat das folgende Speicherlayout:
Die Gesamtgröße dieses 2D-Arrays können wir wie folgt berechnen:
Gesamtgröße = align(8 Bytes + 4 Bytes + Anzahl Zeilen × 4 Bytes)
+ Anzahl Zeilen × align(8 Bytes + 4 Bytes + Anzahl Spalten × Größe des Elementtyps in Bytes)
Für die Beispielmatrix mit zwei Zeilen und drei Spalten ergibt sich:
Gesamtgröße = align(8 Bytes + 4 Bytes + 2 × 4 Bytes) + 2 × align(8 Bytes + 4 Bytes + 3 × 4 Bytes)
= align(20 Bytes) + 2 × align(24 Bytes)
= 24 Bytes + 2 × 24 Bytes
= 72 Bytes
Maximale Array-Größe in Java
Java-Arrays benutzen als Index ein int, und damit liegt die theoretische Obergrenze bei Integer.MAX_VALUE, also bei 2.147.483.647 Elementen.
Ein int-Array dieser Größe würde entsprechend der Formel oben etwas über 8 GB belegen. Das sollte für die meisten modernen Rechner kein Problem darstellen.
Bei mir führt der Versuch, ein Array dieser Größe zu erstellen – egal welchen primitiven Typ ich verwende –, zu folgendem Fehler:
Exception in thread „main“ java.lang.OutOfMemoryError: Requested array size exceeds VM limit
Erst wenn ich die Größe um zwei auf 2.147.483.645 reduziere, funktioniert es – und zwar wiederum bei allen primitiven Datentypen, selbst bei long. Die Grenze hat also nichts mit dem verfügbaren Speicher zu tun, sondern wird durch die JVM festgelegt.
Woher kommt diese Grenze? HotSpot rechnet Objektgrößen intern nicht in Bytes, sondern in Words zu 8 Bytes – und einige Codepfade übergeben diese Word-Anzahl als int. Der ungünstigste Fall ist ein long-Array: Jedes Element belegt ein Word, dazu kommen zwei Words für Header und Längenfeld. Damit die Summe noch in einen int passt, darf ein solches Array höchstens Integer.MAX_VALUE - 2 Elemente haben – und dieselbe Grenze gilt für alle Elementtypen, auch für int und byte, deren Arrays in Words gemessen weit kleiner sind. Nachzulesen ist das in arrayOop.hpp, Methode max_array_length().
Die Größe in Bytes spielt für diese Grenze keine Rolle – das über 8 GB große int-Array belegt gut eine Milliarde Words. Die folgende Tabelle zeigt die maximale Array-Größe für alle primitiven Typen – sowohl in Bezug auf die Anzahl der Elemente als auch auf den belegten Heap-Speicher auf meiner JVM:
| Typen | Maximale Elemente | Maximale Größe im Heap |
|---|---|---|
| boolean, byte | Integer.MAX_VALUE - 2 | 2.147.483.664 Bytes (~ 2 GB) |
| short, char | Integer.MAX_VALUE - 2 | 4.294.967.304 Bytes (~ 4 GB) |
| int, float | Integer.MAX_VALUE - 2 | 8.589.934.592 Bytes (~ 8 GB) |
| long, double | Integer.MAX_VALUE - 2 | 17.179.869.176 Bytes (~ 16 GB) |
Maximale Größe eines 2D-Arrays in Java
Die im vorherigen Kapitel beschriebene Obergrenze gilt für jede Dimension des Arrays. Theoretisch wären also folgende Größen bei zweidimensionalen Arrays möglich:
| Typen | Maximale Elemente | Maximale Größe im Heap |
|---|---|---|
| boolean, byte | (Integer.MAX_VALUE - 2)² | ~ 4 Exabytes (= 4 Millionen Terabytes) |
| short, char | (Integer.MAX_VALUE - 2)² | ~ 8 Exabytes (= 8 Millionen Terabytes) |
| int, float | (Integer.MAX_VALUE - 2)² | ~ 16 Exabytes (= 16 Millionen Terabytes) |
| long, double | (Integer.MAX_VALUE - 2)² | ~ 32 Exabytes (= 32 Millionen Terabytes) |
Hier wird die Größe dann nicht durch die JVM, sondern durch den verfügbaren Speicher bzw. den vom Garbage Collector verwaltbaren Speicher (z. B. 16 TB beim ZGC) begrenzt.
Fazit
Die Länge eines Arrays lässt sich mit array.length bestimmen – length ist ein Feld, keine Methode. Festlegen können wir die Länge eines Arrays nur bei dessen Erzeugung. Die Länge eines Arrays lässt sich nachträglich nicht ändern.
Arrays haben seit Java 27 einen 8-Byte-Objekt-Header und ein 4-Byte-Längenfeld, gefolgt von den Daten (1 Byte pro byte/boolean, 2 Bytes pro short/char, 4 Bytes pro int/float oder Objekt-Referenz und 8 Bytes pro long/double). Bis Java 26 war der Header 12 Bytes groß.
Ein Array kann (auf den meisten JVMs) maximal Integer.MAX_VALUE - 2 Elemente enthalten, unabhängig vom Typ der Array-Elemente.
Hat dir dieser Artikel Zeit gespart? Dann freue ich mich, wenn du eine Minute davon in eine Bewertung auf meinem ProvenExpert-Profil investierst. Dein Feedback zeigt mir, dass sich die Arbeit an diesen Artikeln lohnt.
