Il s'agit d'un nouveau contenu introduit après jdk1.5 Comme j'insiste sur le fait que la publication est le meilleur souvenir, j'ai décidé de remplacer ma mémoire par un blog :
La spécification du langage Java dit : Dans de nombreux cas, l'empaquetage et le déballage sont effectués par le compilateur lui-même (dans ce cas, l'empaquetage est appelé boxing, et le déballage est appelé unboxing) ;
En fait, selon ma propre compréhension, la boxe automatique peut être simplement comprise comme encapsulant des types de données de base dans des types d'objet pour se conformer à l'orientation objet de Java, par exemple, utilisez int comme exemple :
Copiez le code comme suit :
//Déclare un objet Integer
Nombre entier = 10 ;
//L'instruction ci-dessus utilise la boxe automatique : analysée comme
Integer num = new Integer(10); Ce qui précède est un bon exemple, car 10 appartient au type de données de base, en principe, il ne peut pas être directement affecté à un objet Integer, mais après jdk1.5, vous pouvez faire cette déclaration, ceci. C'est le charme de l'autoboxing pour convertir automatiquement les types de données de base en types encapsulés correspondants. Après être devenu un objet, vous pouvez appeler toutes les méthodes déclarées par l'objet pour le déballer automatiquement : d'où son nom, cela signifie reconvertir l'objet en un type de données de base :
//boxe
Nombre entier = 10 ;
//déballage
int num1 = num; Une utilisation très typique du déballage automatique est lors de l'exécution d'opérations : parce que les objets ne sont pas directement exploités, mais doivent être convertis en types de données de base avant que l'addition, la soustraction, la multiplication et la division puissent être effectuées.
Nombre entier = 10 ;
// Le déballage automatique est implicite lors de l'exécution des calculs
System.out.print(num--); Haha, cela devrait sembler très simple. Maintenant, je vais parler de quelque chose d'un peu plus difficile.
//Nombres en dehors de -128~127
Nombre entier1 = 297 ; Nombre entier2 = 297 ;
System.out.println("num1==num2: "+(num1==num2));
// Nombre compris entre -128 et 127
Nombre entier3 = 97 ; Nombre entier4 = 97 ;
System.out.println("num3==num4: "+(num3==num4)); Le résultat imprimé est : num1==num2: false num3==num4: true
C'est étrange : cela est dû à la conception Java de boxe et de déballage automatiques d'Integer et d'int. C'est un mode : appelé mode poids mouche (flyweight).
Afin d'augmenter la réutilisation des nombres simples, Java définit : Lors du boxing automatique, pour les valeurs comprises entre 128 et 127, après leur boxing en objets Integer, elles seront stockées en mémoire pour réutilisation, et il n'y en aura toujours qu'un. objet. Et s'il dépasse la valeur comprise entre 128 et 127, l'Inte encadré. L'objet ger ne sera pas réutilisé, ce qui équivaut à créer un nouvel objet Integer à chaque fois qu'il est encadré ; comprenez, le phénomène ci-dessus est causé par l'utilisation de la boxe automatique, mais suivez les cours généraux. , si vous utilisez new pour instancier, un nouvel objet sera créé à chaque fois que new est utilisé ;
Ce boxing et unboxing automatique n'est pas seulement utilisé dans les types de données de base, mais également dans la classe String. Par exemple, lorsque nous déclarons souvent un objet String :
Copiez le code comme suit :
Chaîne str = "sl" ;
//Remplacez la méthode de déclaration suivante
Chaîne str = new String("sl");
Le boxing automatique et le déballage des types de données de base (primitives) sont des fonctions fournies depuis J2SE 5.0. Bien qu'il soit pratique pour regrouper les types de données de base, il masque également les détails. Il est recommandé de l'utiliser uniquement lorsque vous pouvez distinguer la différence entre les types de données de base et les objets.
autoboxing et unboxing
En Java, presque tout ce qui doit être traité est un objet (Object). Par exemple, le Scanner utilisé auparavant est un objet, et la String (String) est également un objet Nous verrons plus d'objets plus tard. Cependant, les types de données de base ne sont pas des objets, c'est-à-dire des variables que vous définissez à l'aide de int, double, boolean, etc., et des constantes littérales dans lesquelles vous écrivez directement.
Dans la section précédente, nous avons vu grossièrement la commodité de faire fonctionner des objets, et quiconque utilise Java depuis un certain temps sait qu'il est parfois nécessaire de convertir des types de données de base en objets. Par exemple, lors de l'utilisation de la méthode put() d'un objet Map, les paramètres qui doivent être transmis sont des objets plutôt que des types de données de base.
Vous devez utiliser des types wrapper (Wrapper Types) pour envelopper les types de données de base dans des objets. Dans la section précédente, vous savez déjà qu'avant J2SE 5.0, vous devez utiliser l'instruction suivante pour envelopper int dans un objet Integer : Integer integer = new. Entier(10) ;
La fonction d'auto-boxing est fournie après J2SE 5.0. Vous pouvez directement utiliser l'instruction suivante pour regrouper les types de données de base : Integer integer = 10;
Lors de la compilation, le compilateur déterminera automatiquement s'il doit effectuer une boxe automatique en fonction des instructions que vous avez écrites. Dans l'exemple ci-dessus, entier fait référence à une instance de la classe Integer. La même action peut être appliquée aux types de données de base tels que boolean, byte, short, char, long, float, double, etc. Les types de wrapper correspondants (Wrapper Types) Boolean, Byte, Short, Character, Long, Float ou Double seront être utilisés respectivement. Utilisons directement la fonction autoboxing pour réécrire l'exemple 4.4.
Exemple 4.5 AutoBoxDemo.java
Copiez le code comme suit :
classe publique AutoBoxDemo {
public static void main (String[] arguments) {
Données entières1 = 10 ;
Données entières2 = 20 ;
//Convertir en valeur double et diviser par 3
System.out.println(data1.doubleValue() / 3);
//Comparez deux valeurs
System.out.println(data1.compareTo(data2));
}
}
Le programme semble beaucoup plus simple. data1 et data2 sont des instances d'Integer au moment de l'exécution et peuvent effectuer directement des opérations sur les objets. Le résultat est le suivant :
3.3333333333333335
1
La méthode d'utilisation de la boxe automatique peut également être la suivante :
Copiez le code comme suit :
entier je = 10 ;
Entier entier = i ;
Vous pouvez également utiliser la classe java.lang.Number plus générale pour l'autoboxing. Par exemple:
Nombre nombre = 3,14f ;
3.14f sera automatiquement encadré comme Float puis attribué à un numéro.
À partir de J2SE 5.0, le boxing et le unboxing automatiques sont disponibles, c'est-à-dire que les informations de base du formulaire de données dans l'objet sont automatiquement supprimées de l'objet. Par exemple, il est possible d'écrire ce qui suit :
Copiez le code comme suit :
Entier fooInteger = 10 ;
int fooPrimitive = fooInteger;
Une fois que fooInteger est référencé à une instance qui est automatiquement encadrée comme Integer, si elle est affectée à une variable fooPrimitive de type int, elle sera automatiquement modifiée en type int puis affectée à fooPrimitive. Pendant le fonctionnement, un boxing et un unboxing automatiques peuvent également être effectués. Par exemple:
Copiez le code comme suit :
Entier je = 10 ;
System.out.println(i + 10);
System.out.println(i++);
Dans l'exemple ci-dessus, 20 et 10 seront affichés. Le compilateur effectuera automatiquement le boxing et le unboxing, c'est-à-dire que 10 sera d'abord boxé, puis déballé d'abord lorsque i + 10, et l'opération d'addition sera effectuée i++ ; La ligne sera également mise en boîte en premier, puis effectuera une opération d'incrémentation. Regardons un autre exemple :
Copiez le code comme suit :
Booléen boo = vrai ;
System.out.println(boo && false);
Le même boo est à l'origine une instance de Boolean Lors de l'exécution d'une opération AND, boo sera d'abord déballé, puis AND avec false, et le résultat affichera false.
/////////////////////////////////////////////// /// /////////////////
Boxing : la conversion d'un type de base en un type d'objet est appelée boxing ; ***Unboxing : l'opération de conversion d'un objet en un type de base est appelée unboxing. Cette opération est couramment utilisée dans le processus de réflexion.
Emballage : créez une instance d'objet dans le tas et copiez la valeur que vous spécifiez ; ***Unboxing : déterminez si les informations dans le tas pointées par la référence sont du type à diviser, puis prenez la valeur du tas et envoyez-la. à la variable de pile, sinon une exception sera signalée
/////////////////////////////////////////////// /// //////////////////
La boxe est une conversion ermite d'un type valeur en un type objet ou en tout type d'interface implémenté par le type valeur.
Le boxing d’un type valeur alloue une instance d’objet et copie la valeur dans un nouvel objet.
Copiez le code comme suit :
entier je = 123 ;
objet o = je;
Le résultat de cette phrase est de créer un objet o sur la pile, qui fait référence à une valeur de type int sur le tas. Cette valeur est affectée à la variable i
Une copie de la valeur du type de valeur.
Ci-dessous se trouve un affichage qui effectue la conversion de boxe
Copiez le code comme suit :
entier je = 123 ;
objet o=(objet)i;
Cet exemple convertit la variable entière i en objet o via la boxe. De cette façon, la valeur stockée dans la variable i passe de 123 à 456. Cet exemple montre que l'objet conserve une copie originale du contenu. Cela fait 123.
Le déballage est une conversion explicite d'un type d'objet en un type valeur ou d'un type d'interface en un type valeur qui implémente l'interface. Les opérations de déballage comprennent :
Vérifie l’instance d’objet pour s’assurer qu’il s’agit d’une valeur encadrée du type de valeur donné.
Copie la valeur de l'instance dans une variable de type valeur.
exemple:
Copiez le code comme suit :
entier je = 123 ;
boîte d'objet = i ;
int j=(int)boîte;
