java array length feature imagejava array length feature image
HappyCoders Glasses

Array-Länge in Java

Sven Woltmann
Sven Woltmann
Aktualisiert: 14. April 2024

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();Code-Sprache: Java (java)

Dann finden wir die Länge dieses Arrays, also die Anzahl von Einträgen darin, wie folgt heraus:

int numberOfCustomers = customers.length;Code-Sprache: Java (java)

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 2 und Breite 3 würde etwa so repräsentiert werden:

Java 2D-Array

Höhe und Breite könnten wir jetzt wie folgt bestimmen:

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

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.

Beachte aber bitte, dass bei einem zweidimensionalen Array in Java nicht zwingendermaßen alle Unter-Arrays gleich lang sein müssen. Ein 2D-Array könnte auch so aussehen:

Java 2D-Array mit unterschiedlich langen Unter-Arrays

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);
Code-Sprache: Java (java)

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}Code-Sprache: Klartext (plaintext)

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.

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 4:

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

Ein String-Array derselben Größe können wir auch wie folgt festlegen:

String[] fruits = new String[4];Code-Sprache: Java (java)

Dieses Array enthält dann allerdings noch keine Werte, sondern wird mit null an jeder Position initialisiert. Alles über die Initialisierung von Strings 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-Arrays 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}}Code-Sprache: Java (java)

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];Code-Sprache: Java (java)

Dies erzeugt das folgende Array:

Java 2D-Array Matrix mit Nullen

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 bei Compressed Oops, also komprimierten Pointern, der Standardeinstellung auf 64-Bit-Maschinen zum Stand von Java 22 (also noch bevor durch Project Lilliput der Header weiter komprimiert wird).

Ein Array ist in Java ein Objekt und hat damit – wie jedes andere Objekt auch – einen 12-Byte-Objekt-Header. Darauf folgen vier Bytes, in denen die Länge des Arrays hinterlegt ist. Danach folgen die eigentlichen Elemente des Arrays in sequentieller Anordnung.

Beispielsweise ist das int-Array [6, 1, 1, 5, 7] wie folgt im Speicher abgelegt:

Java int-Array Speicherlayout

Die mit „padding“ gekennzeichneten letzten vier Bytes sind nicht wirklich Teil des Arrays, können aber auch nicht anderweitig verwendet werden, da Objekte im Java-Heap bei Compressed Oops an durch acht teilbaren Speicheradressen abgelegt werden. Der Grund dafür ist, dass wir so mit 32 Bit nicht nur 232 Bytes, also 4 GB, sondern die achtfache Menge, also 32 GB, adressieren können.

Elemente in primitiven Arrays belegen jeweils den folgenden Speicherplatz:

  • boolean und byte: je 1 Byte
  • short und char: je 2 Bytes
  • int und float: je 4 Bytes
  • long und double: je 8 Bytes

Mit short- statt int-Werten hätte das Array folgendes Layout:

java short array

Und mit byte-Elementen hätte es folgendes Layout:

java byte array

Die Gesamtgröße eines Arrays können wir wie folgt ausrechnen:

Gesamtgröße = align(12 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 den „verschwendeten“ Platz beinhaltet.

Für das int-Array mit 5 Elementen ergibt sich also folgende Größe:

Gesamtgröße = align(12 Bytes + 4 Bytes + 5 × 4 Bytes)
= align(36 Bytes)
= 40 Bytes

Würden wir die gleichen fünf Elemente in einem long-Array speichern, hätte es folgende Größe:

Gesamtgröße = align(12 Bytes + 4 Bytes + 5 × 8 Bytes)
= align(56 Bytes)
= 56 Bytes

Bei Objekt-Arrays werden nicht die Objekte selbst im Array abgelegt, sondern die Referenzen auf die Objekte. Die folgende Grafik zeigt das Speicherlayout des oben gezeigten String-Arrays:

Java String-Array Speicherlayout

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 eigentlichen Zeichen des Strings.

Wie viel Speicherplatz belegt ein 2D-Array in Java?

Ein zweidimensionales Array ist, wie du oben gesehen hast, eigentlich ein Array von Arrays. Wir müssen also den Speicherplatz des äußeren Arrays und den aller inneren Arrays addieren.

Das Array aus dem oben gezeigten Beispiel hat das folgende Speicherlayout:

Java 2D-Array Speicherlayout

Die Gesamtgröße dieses 2D-Arrays können wir wie folgt berechnen:

Gesamtgröße = align(12 Bytes + 4 Bytes + Anzahl Zeilen × 4 Bytes)
+ Anzahl Zeilen × align(12 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(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

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 reduziere auf 2.147.483.645, dann 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 VM festgelegt.

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 VM:

TypenMaximale ElementeMaximale Größe im Heap
boolean, byteInteger.MAX_VALUE - 22.147.483.664 Bytes (~ 2 GB)
short, charInteger.MAX_VALUE - 24.294.967.312 Bytes (~ 4 GB)
int, floatInteger.MAX_VALUE - 28.589.934.600 Bytes (~ 8 GB)
long, doubleInteger.MAX_VALUE - 217.179.869.176 Bytes (~ 16 GB)

Maximale Größe eines 2D-Arrays in Java

Die im vorherigen Kapital beschriebene Obergrenze gilt für jede Dimension des Arrays. Theoretisch wären also folgende Größen bei zweidimensionalen Arrays möglich:

TypenMaximale ElementeMaximale 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 VM, 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. 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 bei Compressed Oops einen 12-Byte-Objekt-Header und ein 4-Byte-Längenfeld, gefolgt von den eigentlichen 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).

Ein Array kann (auf den meisten VMs) maximal Integer.MAX_VALUE - 2 Elemente enthalten, unabhängig vom Typ der Array-Elemente.

Wenn dir der Artikel gefallen hat, teile den Artikel über einen der Share-Buttons am Ende oder hinterlasse mir einen Kommentar.

Möchtest du informiert werden, wenn neue Artikel auf HappyCoders.eu veröffentlicht werden? Dann klicke hier, um dich für den HappyCoders.eu-Newsletter anzumelden.