Classe Java Wrapper (Wrapper)

In this tutorial, we will learn about Java Wrapper classes (Wrapper) with examples.

Wrapper classes in Java are used to convert primitive types (int, char, float, etc.) to the corresponding objects.

Each of the 8 basic types has a corresponding wrapper class.

Convert primitive types to wrapper objects

We can also use the valueOf() method to convert primitive types to the corresponding objects.

Example 1: Original type of wrapper object

class Main {
　　public static void main(String[] args) {
　　　　//Create primitive type
　　　　int a = 5;
　　　　double b = 5.65;
　　　　//Convert to wrapper object
　　　　Integer aObj = Integer.valueOf(a);
　　　　Double bObj = Double.valueOf(b);
　　　　if(aObj instanceof Integer) {
　　　　　　System.out.println("Creare un oggetto Integer.");
　　　　}
　　　　if(bObj instanceof Double) {
　　　　　　System.out.println("Creare un oggetto Double.");
　　　　}
　　}
}

Risultato di output

Creare un oggetto Integer.
Creare un oggetto Double.

Nel esempio sopra, abbiamo utilizzato il metodo valueOf() per convertire i tipi primitivi in oggetti.

Qui utilizziamo l'operatore instanceof per verificare se l'oggetto generato appartiene al tipo Integer o Double.

Ma il compilatore Java può convertire direttamente i tipi primitivi nel loro oggetto corrispondente. Ad esempio,

int a = 5;
//Convertire in oggetto
Integer aObj = a;
double b = 5.6;
//Convertire in oggetto
Double bObj = b;

Questo processo viene chiamatoInvolucro automatico. Per ulteriori informazioni, visitareImballaggio automatico e smontaggio Java.

AttenzionePossiamo anche utilizzare il costruttore della classe wrapper (Wrapper) per convertire i tipi primitivi in oggetti wrapper.Ma dopo Java 9, non si utilizza più il costruttore.

Wrapper in tipo primitivo

Per convertire un oggetto nel suo tipo primitivo corrispondente, possiamo utilizzare i metodi di valore (intValue(), doubleValue() ecc.) disponibili in ogni classe wrapper.

Esempio 2: Convertire gli oggetti wrapper nel tipo primitivo

class Main {
　　public static void main(String[] args) {
　　　　//Creare un oggetto della classe wrapper
　　　　Integer aObj = Integer.valueOf(23);
　　　　Double bObj = Double.valueOf(5.55);
　　　　//Convertire nel tipo primitivo
　　　　int a = aObj.intValue();
　　　　double b = bObj.doubleValue();
　　　　System.out.println("Valore di a: " + a);
　　　　System.out.println("Valore di b: " + b);
　　}
}

Risultato di output

Valore di a: 23
Valore di b: 5.55

Nel esempio sopra, abbiamo utilizzato i metodi intValue() e doubleValue() per convertire gli oggetti Integer e Double nel loro tipo primitivo corrispondente.

Ma il compilatore Java può automaticamente convertire gli oggetti nel loro tipo primitivo corrispondente. Ad esempio,

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

Questo processo viene chiamatoSmontaggio. Per ulteriori informazioni, visitareImballaggio automatico e smontaggio Java.

Vantaggi delle classi wrapper

• A volte, in Java, potremmo aver bisogno di utilizzare oggetti invece dei tipi di dati primitivi. Ad esempio, quando si utilizzano set.

  // Errore
  ArrayList<int> list = new ArrayList<>();
  // Operazione normale
  ArrayList<Integer> list = new ArrayList<>();

  In questo caso, le classi wrapper possono aiutarci a utilizzare i tipi di dati primitivi come oggetti.

• Possiamo memorizzare valori nulli negli oggetti wrapper. Ad esempio:

  // Genererà un errore
  int a = null;
  // Operazione normale
  Integer a = null;

AttenzioneI tipi di base sono più efficienti rispetto agli oggetti corrispondenti. Pertanto, quando è necessario l'efficienza, si consiglia sempre di utilizzare i tipi di base.