In questo tutorial impareremo a conoscere la classe Java Wrapper con l'aiuto di esempi.
Le classi involucro in Java vengono utilizzati per convertire tipi primitivi ( int, char, float, ecc) in oggetti corrispondenti.
Ciascuno degli 8 tipi primitivi ha classi wrapper corrispondenti.
| Tipo primitivo | Classe wrapper |
|---|---|
byte | Byte |
boolean | Boolean |
char | Character |
double | Double |
float | Float |
int | Integer |
long | Long |
short | Short |
Converti il tipo primitivo in oggetti wrapper
Possiamo anche usare il valueOf()metodo per convertire i tipi primitivi in oggetti corrispondenti.
Esempio 1: tipi primitivi per wrapper oggetti
class Main ( public static void main(String() args) ( // create primitive types int a = 5; double b = 5.65; //converts into wrapper objects Integer aObj = Integer.valueOf(a); Double bObj = Double.valueOf(b); if(aObj instanceof Integer) ( System.out.println("An object of Integer is created."); ) if(bObj instanceof Double) ( System.out.println("An object of Double is created."); ) ) )
Produzione
Viene creato un oggetto di Integer. Viene creato un oggetto di Double.
Nell'esempio precedente, abbiamo utilizzato il valueOf()metodo per convertire i tipi primitivi in oggetti.
Qui abbiamo utilizzato l' instanceofoperatore per verificare se gli oggetti generati sono di Integero di Doubletipo oppure no.
Tuttavia, il compilatore Java può convertire direttamente i tipi primitivi in oggetti corrispondenti. Per esempio,
int a = 5; // converts into object Integer aObj = a; double b = 5.6; // converts into object Double bObj = b;
Questo processo è noto come auto-boxing . Per saperne di più, visita Autoboxing e unboxing di Java.
Nota : possiamo anche convertire i tipi primitivi in oggetti wrapper utilizzando Wrapperi costruttori di classi. Ma l'uso dei costruttori viene scartato dopo Java 9.
Inserisci oggetti in tipi primitivi
Per convertire gli oggetti in tipi primitivi, possiamo usare i metodi valori corrispondenti ( intValue(), doubleValue(), ecc) presente in ogni classe involucro.
Esempio 2: wrapper oggetti in tipi primitivi
class Main ( public static void main(String() args) ( // creates objects of wrapper class Integer aObj = Integer.valueOf(23); Double bObj = Double.valueOf(5.55); // converts into primitive types int a = aObj.intValue(); double b = bObj.doubleValue(); System.out.println("The value of a: " + a); System.out.println("The value of b: " + b); ) )
Produzione
Il valore di a: 23 Il valore di b: 5,55
Nell'esempio precedente, abbiamo utilizzato il metodo intValue()e doubleValue()per convertire gli oggetti Integere Doublenei corrispondenti tipi primitivi.
Tuttavia, il compilatore Java può convertire automaticamente gli oggetti nei corrispondenti tipi primitivi. Per esempio,
Integer aObj = Integer.valueOf(2); // converts into int type int a = aObj; Double bObj = Double.valueOf(5.55); // converts into double type double b = bObj;
Questo processo è noto come unboxing . Per saperne di più, visita Autoboxing e unboxing di Java.
Vantaggi delle classi wrapper
- In Java, a volte potrebbe essere necessario utilizzare oggetti invece di tipi di dati primitivi. Ad esempio, mentre si lavora con le raccolte.
In questi casi, le classi wrapper ci aiutano a utilizzare tipi di dati primitivi come oggetti.// error ArrayList list = new ArrayList(); // runs perfectly ArrayList list = new ArrayList(); - Possiamo memorizzare il valore nullo negli oggetti wrapper. Per esempio,
// generates an error int a = null; // runs perfectly Integer a = null;
Nota : i tipi primitivi sono più efficienti degli oggetti corrispondenti. Quindi, quando l'efficienza è il requisito, si consigliano sempre tipi primitivi.
