Java Wrapper-klasse

In deze tutorial leren we de Java Wrapper-klasse kennen met behulp van voorbeelden.

Java wrapper-klassen converteren primitieve typen (int, char, float, etc.) naar hun bijbehorende objectrepresentaties.

Elk van de acht primitieve typen heeft een eigen wrapper-klasse.

Primitieve typen omzetten naar wrapper-objecten

Gebruik de methode valueOf() om een primitief expliciet om te zetten in het bijbehorende wrapper-object.

Voorbeeld 1: Primitieve typen naar wrapper-objecten

class Main {
    public static void main(String[] args) {
        int a = 5;
        double b = 5.65;
        Integer aObj = Integer.valueOf(a);
        Double bObj = Double.valueOf(b);
        if(aObj instanceof Integer) {
            System.out.println("Een object van Integer is aangemaakt.");
        }
        if(bObj instanceof Double) {
            System.out.println("Een object van Double is aangemaakt.");
        }
    }
}

Output

Een object van Integer is aangemaakt. Een object van Double is aangemaakt.

De bovenstaande code demonstreert expliciete conversie via valueOf(). Java ondersteunt ook auto-boxing, waarbij primitieven impliciet worden ingewikkeld:

int a = 5;
Integer aObj = a;
double b = 5.6;
Double bObj = b;

Meer over autoboxing en unboxing vind je in onze speciale gids.

Let op: Voor Java 9 konden wrapper-objecten ook via constructors worden aangemaakt (bijv. new Integer(a)), maar deze benadering is verouderd.

Wrapper-objecten omzetten naar primitieve typen

Om de onderliggende primitieve waarde op te halen, roep je de bijbehorende …Value()-methode aan op het wrapper-object.

Voorbeeld 2: Wrapper-objecten naar primitieve typen

class Main {
    public static void main(String[] args) {
        Integer aObj = Integer.valueOf(23);
        Double bObj = Double.valueOf(5.55);
        int a = aObj.intValue();
        double b = bObj.doubleValue();
        System.out.println("De waarde van a: " + a);
        System.out.println("De waarde van b: " + b);
    }
}

Output

De waarde van a: 23 De waarde van b: 5.55

Java voert ook unboxing automatisch uit:

Integer aObj = Integer.valueOf(2);
int a = aObj;
Double bObj = Double.valueOf(5.55);
double b = bObj;

Zie het artikel over autoboxing en unboxing voor diepere inzichten.

Voordelen van wrapper-klassen

• Wanneer collecties objecten vereisen, bruggen wrapper-klassen de kloof tussen primitieven en objecten.

  // fout
  ArrayList<int> lijst = new ArrayList<>();
  // werkt perfect
  ArrayList<Integer> lijst = new ArrayList<>();

• Wrapper-objecten kunnen null bevatten, wat nullable referenties toelaat.

  // genereert een fout
  int a = null;
  // werkt perfect
  Integer a = null;

Let op: Primitieve typen zijn doorgaans efficiënter dan hun object-counterparts; gebruik primitieven wanneer prestaties cruciaal zijn.