⟨info/⟩

Object[]

Referenz

Speichert Referenzen auf beliebige Java-Objekte. Die flexibelste Array-Form — kann jede Klasse speichern, erfordert aber Typ-Casts.

Standardwert:null

Visualisierung

Object[]5 Elemente
"Text"
[0]
42
[1]
true
[2]
null
[3]
3.14
[4]
Länge:5
Letzter Index:4
Standardwert:null

Deklaration

So reservierst du Speicher für einen Object[].

// Deklaration (Standardwerte: null)
Object[] mixed = new Object[5];

// Kann jeden Referenztyp aufnehmen
Object[] alles = new Object[10];

Initialisierung

Verschiedene Wege, ein Object[] mit Werten zu befüllen.

// Gemischte Typen möglich (Auto-boxing für Primitive)
Object[] mixed = {"Text", 42, true, null, 3.14};
// Java boxed automatisch: int → Integer, boolean → Boolean, double → Double

// Eigene Objekte
Object[] personen = {new Person("Alice", 30), new Person("Bob", 25)};

// Arrays von Arrays (Jagged Arrays)
Object[] verschachtelt = {new int[]{1,2,3}, new String[]{"a","b"}};

Typische Operationen

Zugriff, Änderung, Iteration und häufige Patterns mit Object[].

Object[] arr = {"Text", 42, true, null, 3.14};

// Zugriff – gibt Object zurück, Cast nötig!
Object o = arr[0];             // Object-Referenz
String s = (String) arr[0];    // Cast zu String → "Text"

// instanceof prüfen vor Cast (ClassCastException vermeiden)
for (Object obj : arr) {
    if (obj instanceof String str) {    // Pattern Matching (Java 16+)
        System.out.println("String: " + str.toUpperCase());
    } else if (obj instanceof Integer i) {
        System.out.println("Int: " + (i * 2));
    } else if (obj instanceof Boolean b) {
        System.out.println("Bool: " + !b);
    } else if (obj == null) {
        System.out.println("null");
    }
}

// Sortieren nur möglich wenn alle Elemente Comparable implementieren
// Arrays.sort(arr); // RuntimeException bei gemischten Typen!

// Besser: ArrayList<Object> oder generische Typen verwenden
import java.util.ArrayList;
ArrayList<Object> liste = new ArrayList<>();
liste.add("Text");
liste.add(42);

Hintergründe & Details

Object[] ist der allgemeinste Array-Typ in Java — da alle Klassen implizit von Object erben, kann ein Object[]-Array Referenzen auf jede beliebige Klasse speichern. Sogar primitive Werte können gespeichert werden, da Java sie automatisch "boxt" (int → Integer, boolean → Boolean, etc.).

Typ-Sicherheit fehlt: Das ist der große Nachteil. Wenn du ein Element aus einem Object[]-Array holst, erhältst du nur Object. Du musst explizit casten (String s = (String) arr[0]) — und wenn der Typ falsch ist, gibt es eine ClassCastException zur Laufzeit. Generics (ArrayList<String>) sind typsicher und bevorzugt.

instanceof und Pattern Matching: Vor Java 16 musstest du instanceof prüfen, dann extra casten. Seit Java 16 gibt es Pattern Matching: if (obj instanceof String str) — prüft und castet in einem Schritt.

Wann Object[] verwenden? Meist dann, wenn du mit sehr altem Java-Code oder Reflection arbeitest, oder wenn du wirklich heterogene Daten speichern musst. In modernem Java bevorzuge Generics: List<String>, Map<String, Integer>, usw.