Object[]
ReferenzSpeichert Referenzen auf beliebige Java-Objekte. Die flexibelste Array-Form — kann jede Klasse speichern, erfordert aber Typ-Casts.
nullVisualisierung
54nullDeklaration
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.