Wrapper-Klassen in Java

Thema in Kurzform

// primitiver Datentyp int
int i = 2;

// Objekt vom Typ Integer
Integer intWrapper = new Integer(2);

// Mithilfe der Wrapper sind Listen mit Zahlenwerten möglich:
ArrayList<Integer> liste = new ArrayList<>();
liste.add(10);
liste.add(20);

Inhaltsverzeichnis

1. Was sind Wrapper-Klassen?
2. Autoboxing
3. Wozu sind Wrapper-Klassen gut?
4. Übungen

Was sind Wrapper-Klassen

In der Java Standardbibliothek gibt es zu jedem primitiven Datentyp eine korrespondierende Klasse. Diese Klassen werden Wrapper-Klassen genannt.

Übersetzt bedeutet das Wort wrapper soviel wie "Verpackung" oder "Hülle", womit der Charakter dieser Klassen bereits angedeutet ist:

• Instanzen der Wrapper-Klassen dienen als objektorientierte Hüllen um primitive Werte.

Integer intWrapper = new Integer(7);
Double doubleWrapper = new Double(2.8);

Hier sehen wir zwei Beispiele für Objekte der Wrapper-Klassen Integer und Double. Den jeweiligen Konstruktoren übergeben wir die primitiven Werte 7 bzw. 2.8, die damit in den entsprechenden Objekten verpackt sind. Man nennt dies Boxing.

Die Wrapper-Klassen haben bestimmte Methoden, mit denen wir den primitiven Wert wieder zurückgeliefert bekommen (Unboxing).

int intPrimitiv = intWrapper.intValue();
double doublePrimitive = doubleWrapper.doubleValue();

System.out.println(intPrimitiv); // 7
System.out.println(doublePrimitive); // 2.8

Bei den anderen Wrapper-Klassen heißen die Methoden analog: booleanValue(), byteValue() und so weiter.

Autoboxing

Um diese umständliche Syntax zu vereinfachen, sind seit Java 5 die Methoden intValue(), doubleValue() usw. für das Unboxing nicht mehr zwingend notwendig. Es genügt dem Compiler, wenn wir einfach die Referenzvariable notieren. Er führt die entsprechende Rückgabe des primitiven Werts dann automatisch aus:

System.out.println(intWrapper); // 7
System.out.println(doubleWrapper); // 2.8

Dieses Prinzip nennt man Autoboxing.

Mit dem Autoboxing können wir sogar noch einen Schritt weitergehen und uns die explizite Objekterzeugung mit new auch ganz sparen:

Integer intWrapper1 = new Integer(10);
Integer intWrapper2 = 20; // Autoboxing

Der Compiler weiß, dass nach der Deklaration der Integer-Variablen ein Integer-Objekt folgen muss. Schreiben wir nun das int-Literal (20) hinter den Zuweisungsoperator, erzeugt Java für uns "automatisch" das entsprechende Integer-Objekt.

Wozu sind Wrapper-Klassen gut?

Arbeiten mit Listen

Stellen wir uns einmal vor, wir möchten eine ArrayList erstellen, die Zahlen speichert. Kann folgender Versuch gelingen?

ArrayList<int> zahlenListe = new ArrayList<>(); // error!

Wie wir wissen, ist ArrayList eine generische Klasse und Generics funktionieren ausschließlich mit Objekttypen. Da int kein Objekttyp ist, kann das auf diese Weise also nicht funktionieren.

Mithilfe der Wrapper-Klassen allerdings bekommen wir unsere ArrayList mit Zahlen:

ArrayList<Integer> zahlenListe = new ArrayList<>(); // cool!

Statt dem primitiven Datentyp int tragen wir in die eckigen Klammern also Integer ein. Damit hat ArrayList, was es braucht: Einen Objekttyp.

Befüllen wir unsere Liste nun mit ein paar Integer-Objekten:

zahlenListe.add(2);
zahlenListe.add(8);

Auch hier kommt wieder das Autoboxing zum Tragen: Der Compiler weiß nämlich durch die Deklaration ArrayList<Integer>, dass diese ArrayList nur Objekte der Wrapper-Klasse Integer aufnimmt. Tragen wir jetzt primitive int-Werte (wie 2 und 8) als Argumente in die add-Methode ein, wandelt Java diese automatisch in die entsprechenden Objekttypen um.

String in primitiven Wert umwandeln

Mithilfe der Wrapper-Klassen können wir Strings in primitive Werte parsen. Dies gelingt uns mit folgenden statischen Methoden der einzelnen Wrapper-Klassen:

static boolean parseBoolean(String s)
static byte parseByte(String s)
static short parseShort(String s)
static int parseInt(String s)
static long parseLong(String s)
static float parseFloat(String s)
static double parseDouble(String s)
static int parseInt(String s)

Ein paar konkrete Beispiele:

String s = "22";
int i = Integer.parseInt(s); // 22

String s2 = "19.99";
double d = Double.parseDouble(s2); // 19.99

Die parseXXX-Methoden sind in Java besonders bei der Verarbeitung von GUI-Benutzereingaben wichtig. Diese werden nämlich als String an das Programm gesendet. Stellen wir uns nur mal vor, ein Benutzer gibt zwei Zahlen in Eingabefelder ein, die das Programm dann verrechnen soll. Das wäre mit Strings unmöglich:

String input1 = "8.2";
String input2 = "1.8";
double summe = input1 + input2; // Fehler!

Deshalb müssen diese auf jeden Fall in entsprechende primitive Werte umgewandelt werden:

double summe = Double.parseDouble(input1) + Double.parseDouble(input2); // 10.0

Übungen

ArrayList<Double> liste = new ArrayList<>();
liste.add(11.1);
liste.add(22.2);
liste.add(-33.3);

int i1 = Integer.parseInt("731");
int i2 = Integer.parseInt("731.20");

boolean b1 = Boolean.parseBoolean("true");
boolean b2 = Boolean.parseBoolean(true);

ArrayList<Integer> zahlen = new ArrayList<>();
zahlen.add(Integer.parseInt("4"));
zahlen.add(Integer.valueOf("8"));
zahlen.add(12);
zahlen.add(null);

for(int sV : zahlen){
    System.out.println(sV);
}