Zum Inhalt springen

Referenzen und null

Arrays verhalten sich in manchen Situationen anders als int oder double. Das liegt nicht an Arrays, sondern an einem grundlegenden Unterschied: Java kennt primitive Typen und Referenztypen. Wer diesen Unterschied verstanden hat, versteht auch, warum man Texte mit equals vergleichen muss.

  • erklären, was in einer Variable für ein Array oder Objekt steht
  • vorhersagen, wann eine Änderung auch „an anderer Stelle“ sichtbar wird
  • Arrays wirklich kopieren und richtig vergleichen
  • erklären, warum == bei Texten nicht funktioniert
  • mit null umgehen und eine NullPointerException verstehen
Verweise.java
package de.drv;
import java.util.Arrays;
public class Verweise {
public static void main(String[] args) {
int x = 1;
int y = x;
y = 99;
System.out.println("x = " + x + ", y = " + y);
int[] a = {1, 2, 3};
int[] b = a;
b[0] = 99;
System.out.println("a = " + Arrays.toString(a));
System.out.println("b = " + Arrays.toString(b));
}
}
Terminal-Fenster
x = 1, y = 99
a = [99, 2, 3]
b = [99, 2, 3]

Bei int verhält sich alles wie erwartet. Beim Array hat sich a geändert, obwohl wir nur b[0] gesetzt haben. Der Grund liegt darin, was in der Variable steht:

int x = 1; x │ 1 │
int y = x; y │ 1 │ ← eine Kopie des Werts
int[] a = {1, 2, 3}; a │ ●─┼──┐
├──▶ [ 1 | 2 | 3 ]
int[] b = a; b │ ●─┼──┘ ← eine Kopie des Verweises
  • In einer Variable eines primitiven Typs steht der Wert selbst.
  • Ein Array ist ein Objekt. Es wird mit new (oder {…}) irgendwo im Speicher angelegt. In der Variable steht nur ein Verweis darauf – eine Referenz.
  • int[] b = a; kopiert diesen Verweis. Danach zeigen zwei Variablen auf dasselbe Array. Über welche der beiden man es ändert, ist egal.

Das gilt für alle Typen außer den acht primitiven: Arrays, String, Scanner, Random – alles Objekte, alles Referenztypen.

Soll eine unabhängige Kopie entstehen, muss man ein neues Array anlegen:

Kopieren.java
package de.drv;
import java.util.Arrays;
public class Kopieren {
public static void main(String[] args) {
int[] original = {1, 2, 3};
int[] kopie = Arrays.copyOf(original, original.length);
kopie[0] = 99;
System.out.println("original = " + Arrays.toString(original));
System.out.println("kopie = " + Arrays.toString(kopie));
}
}
Terminal-Fenster
original = [1, 2, 3]
kopie = [99, 2, 3]

Im Kapitel Statische Methoden haben wir gesehen: Parameter sind Kopien. Das stimmt auch hier – kopiert wird aber der Verweis:

Uebergabe.java
package de.drv;
import java.util.Arrays;
public class Uebergabe {
public static void main(String[] args) {
int[] werte = {1, 2, 3};
verdoppleAlle(werte);
System.out.println("nach verdoppleAlle: " + Arrays.toString(werte));
ersetze(werte);
System.out.println("nach ersetze: " + Arrays.toString(werte));
}
public static void verdoppleAlle(int[] zahlen) {
for (int i = 0; i < zahlen.length; i++) {
zahlen[i] = zahlen[i] * 2;
}
}
public static void ersetze(int[] zahlen) {
zahlen = new int[] {7, 7, 7};
}
}
Terminal-Fenster
nach verdoppleAlle: [2, 4, 6]
nach ersetze: [2, 4, 6]
  • verdoppleAlle ändert die Elemente des Arrays, auf das zahlen zeigt – und das ist dasselbe Array wie werte in main. Die Änderung ist danach in main sichtbar.
  • ersetze lässt die Variable zahlen auf ein neues Array zeigen. Das betrifft nur die Kopie des Verweises in der Methode – werte in main zeigt weiter auf das alte Array.

Du kennst das schon: Arrays.sort(zahlen) gibt nichts zurück und sortiert trotzdem dein Array – genau so funktioniert es.

Vergleichen.java
package de.drv;
import java.util.Arrays;
public class Vergleichen {
public static void main(String[] args) {
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = a;
System.out.println("a == b: " + (a == b));
System.out.println("a == c: " + (a == c));
System.out.println("Arrays.equals(a, b): " + Arrays.equals(a, b));
}
}
Terminal-Fenster
a == b: false
a == c: true
Arrays.equals(a, b): true

== vergleicht bei Referenztypen die Verweise, nicht die Inhalte: Zeigen beide Variablen auf dasselbe Objekt? a und b haben gleichen Inhalt, sind aber zwei verschiedene Arrays. Für den Inhalt gibt es Arrays.equals.

Auch die seltsame Ausgabe [I@2b2fa4f7 aus dem Kapitel Arrays erklärt sich jetzt: println mit einem Array gibt den Typ ([I steht für „Array von int“) und eine Kennung des Objekts aus – nicht den Inhalt.

Im Kapitel Operatoren hatte == bei der Eingabe ja überraschend false geliefert. Jetzt können wir das erklären:

Texte.java
package de.drv;
import java.util.Scanner;
public class Texte {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String literal = "ja";
String nochEinLiteral = "ja";
System.out.print("Eingabe: ");
String eingabe = scanner.nextLine();
System.out.println("literal == nochEinLiteral: " + (literal == nochEinLiteral));
System.out.println("literal == eingabe: " + (literal == eingabe));
System.out.println("literal.equals(eingabe): " + literal.equals(eingabe));
scanner.close();
}
}
Terminal-Fenster
Eingabe: ja
literal == nochEinLiteral: true
literal == eingabe: false
literal.equals(eingabe): true
  • Ein String ist ein Objekt, == vergleicht also Verweise.
  • Gleiche Literale im Quelltext – hier zweimal "ja" – legt Java nur einmal an. Beide Variablen zeigen auf dasselbe Objekt, deshalb ist == hier zufällig true.
  • Der Scanner erzeugt für jede Eingabe ein neues String-Objekt. Gleicher Inhalt, anderes Objekt – == liefert false.
  • equals vergleicht den Inhalt und ist deshalb immer richtig.

Daher die Regel: Objekte vergleicht man mit equals, nicht mit ==.

Eine Referenzvariable muss nicht auf ein Objekt zeigen. Der besondere Wert null bedeutet: „zeigt auf nichts“.

Nichts.java
package de.drv;
public class Nichts {
public static void main(String[] args) {
String[] namen = new String[3];
namen[0] = "Anna";
System.out.println(namen[0]);
System.out.println(namen[1]);
String name = namen[1];
if (name != null) {
System.out.println(name.length());
}
System.out.println(name.length());
}
}
Terminal-Fenster
Anna
null
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "name" is null
at de.drv.Nichts.main(Nichts.java:16)
  • Ein neues Array von Referenztypen ist mit null gefüllt – so wie ein int-Array mit 0.
  • Ein Methodenaufruf auf null führt zur NullPointerException, der wohl häufigsten Exception überhaupt. Die Meldung sagt genau, was passiert ist: length() sollte aufgerufen werden, aber name war null.
  • Wo eine Variable null sein kann, prüft man vorher mit != null.
primitiver Typ Referenztyp
Beispiele int, double, boolean, char Arrays, String, Scanner, …
In der Variable steht der Wert ein Verweis auf ein Objekt
b = a kopiert den Wert den Verweis – beide zeigen auf dasselbe Objekt
== vergleicht die Werte die Verweise – „dasselbe Objekt?“
Inhalt vergleichen == equals bzw. Arrays.equals
Standardwert im Array 0, false null
  1. Was wird ausgegeben? Überlege erst, dann probiere es aus.

    int[] a = {1, 2};
    int[] b = a;
    a[1] = 5;
    System.out.println(b[1]);
    String s = "Hallo";
    String t = s;
    t = "Welt";
    System.out.println(s);
    int[] c = {1, 2};
    int[] d = {1, 2};
    System.out.println(c == d);
    System.out.println(Arrays.equals(c, d));
    String[] w = new String[2];
    System.out.println(w[0]);
    Lösung
    5
    Hallo
    false
    true
    null
    • b zeigt auf dasselbe Array wie a – die Änderung ist über beide sichtbar.
    • t = "Welt" lässt t auf ein anderes Objekt zeigen. Das Objekt "Hallo" wird dabei nicht verändert, s zeigt weiter darauf.
    • c und d sind zwei verschiedene Arrays mit gleichem Inhalt.
    • Neue Arrays von Referenztypen sind mit null gefüllt.
  2. Schreibe eine Methode verdoppelteKopie(int[] zahlen), die ein neues Array mit den verdoppelten Werten zurückgibt. Das übergebene Array soll unverändert bleiben.

    Lösung
    VerdoppelteKopie.java
    package de.drv;
    import java.util.Arrays;
    public class VerdoppelteKopie {
    public static void main(String[] args) {
    int[] werte = {1, 2, 3};
    int[] doppelt = verdoppelteKopie(werte);
    System.out.println("werte = " + Arrays.toString(werte));
    System.out.println("doppelt = " + Arrays.toString(doppelt));
    }
    public static int[] verdoppelteKopie(int[] zahlen) {
    int[] ergebnis = new int[zahlen.length];
    for (int i = 0; i < zahlen.length; i++) {
    ergebnis[i] = zahlen[i] * 2;
    }
    return ergebnis;
    }
    }
  3. Schreibe eine Methode tausche(int x, int y), die zwei Werte vertauschen soll – und eine Methode tausche(int[] zahlen, int i, int j), die zwei Elemente eines Arrays vertauscht. Welche funktioniert, welche nicht – und warum?

    Lösung

    Die erste Variante tauscht nur die Kopien in der Methode – in main ändert sich nichts. Die zweite bekommt einen Verweis auf das Array und ändert dessen Elemente – das ist in main sichtbar.

    Tauschen.java
    package de.drv;
    import java.util.Arrays;
    public class Tauschen {
    public static void main(String[] args) {
    int a = 3;
    int b = 8;
    tausche(a, b);
    System.out.println("a = " + a + ", b = " + b);
    int[] werte = {3, 8, 5};
    tausche(werte, 0, 1);
    System.out.println("werte = " + Arrays.toString(werte));
    }
    public static void tausche(int x, int y) {
    int hilf = x;
    x = y;
    y = hilf;
    }
    public static void tausche(int[] zahlen, int i, int j) {
    int hilf = zahlen[i];
    zahlen[i] = zahlen[j];
    zahlen[j] = hilf;
    }
    }
  4. Schreibe eine Methode laengsterName(String[] namen), die den längsten Namen zurückgibt. Das Array kann null-Einträge enthalten. Gibt es gar keinen Namen, soll die Methode null zurückgeben.

    Lösung

    Die Reihenfolge in der Bedingung ist wichtig: Erst wird name != null geprüft. Ist das falsch, wertet && den Rest gar nicht mehr aus – und name.length() wird nie auf null aufgerufen.

    LaengsterName.java
    package de.drv;
    public class LaengsterName {
    public static void main(String[] args) {
    String[] namen = {"Anna", null, "Maximilian", "Ben", null};
    System.out.println("Längster Name: " + laengsterName(namen));
    String[] leer = new String[3];
    System.out.println("Längster Name: " + laengsterName(leer));
    }
    public static String laengsterName(String[] namen) {
    String laengster = null;
    for (String name : namen) {
    if (name != null && (laengster == null || name.length() > laengster.length())) {
    laengster = name;
    }
    }
    return laengster;
    }
    }