Analyse approfondie de la boxe et du unboxing automatique Java

Il s'agit d'un nouveau contenu introduit après jdk1.5. Comme j'insiste sur le fait que la publication est la meilleure mémoire, 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é 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 les types de données de base sont encapsulés en tant que types d'objets) ; respecter l'orientation objet de Java ; par exemple, utilisez int comme exemple :

//声明一个Integer对象 
Integer num = 10; 
//以上的声明就是用到了自动的装箱：解析为 
Integer num = new Integer(10);以上就是一个很好的体现，因为10是属于基本数据类型的，原则上它是不能直接赋值给一个对象Integer的，但jdk1.5后你就可以进行这样的声明，这就是自动装箱的魅力 
自动将基本数据类型转化为对应的封装类型。成为一个对象以后就可以调用对象所声明的所有的方法 
自动拆箱：故名思议就是将对象重新转化为基本数据类型： 
//装箱 
Integer num = 10; 
//拆箱 
int num1 = num;自动拆箱有个很典型的用法就是在进行运算的时候：因为对象时不恩直接进行运算的，而是要转化为基本数据类型后才能进行加减乘除 
Integer num = 10; 
//进行计算时隐含的有自动拆箱 
System.out.print(num--);哈哈 应该感觉很简单吧，下面我再来讲点稍微难点的， 
//在-128~127 之外的数 
Integer num1 = 297; Integer num2 = 297; 
System.out.println("num1==num2: "+(num1==num2)); 
// 在-128~127 之内的数 
Integer num3 = 97; Integer num4 = 97; 
System.out.println("num3==num4: "+(num3==num4)); 打印的结果是：num1==num2: false num3==num4: true

C'est étrange : cela est dû à la boxe et au déballage automatiques par Java de Integer et int La conception est un modèle : appelé modèle de poids mouche ( flyweight)
Afin d'augmenter la réutilisation des nombres simples, Java définit : Lors de la boxe automatique, pour les valeurs​​de –128 à 127, ils sont Après avoir été boxés dans un objet Integer, celui-ci sera stocké dans le mémoire pour réutilisation. Il n'y aura toujours qu'un seul objet
et s'il dépasse la valeur comprise entre –128 et 127, l'objet Integer encadré ne sera pas réutilisé, c'est-à-dire que cela équivaut à créer un nouvel objet Integer à chaque fois qu'il l'est. boxed; vous comprenez.
Le phénomène ci-dessus est causé par l'utilisation de la boxe automatique, mais utilisez new comme la classe générale, pour instancier, il y aura un nouvel objet à chaque fois <; 🎜>Ce boxing et unboxing automatique n'est pas seulement utilisé dans les types de données de base, mais aussi dans la classe String. Par exemple, nous déclarons souvent un objet String Quand :

String str = "sl"; 
//代替下面的声明方式 
String str = new String("sl");

Autoboxing et unboxing des données de base (. Les types primitifs) 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 chaîne (String) est également un objet. objet ultérieur. 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 en gros 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 Integer (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; Écrivez l'instruction pour déterminer s'il faut effectuer une action de boxe automatique. 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., et aux types de wrapper correspondants (Wrapper Types) Boolean, Byte, Short, Character, Long, Float ou Le double sera utilisé respectivement. Utilisons directement la fonction autoboxing pour réécrire l'exemple 4.4.

Exemple 4.5 AutoBoxDemo.java

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 :

public class AutoBoxDemo { 
public static void main(String[] args) { 
Integer data1 = 10; 
Integer data2 = 20; 
// 转为double值再除以3 
System.out.println(data1.doubleValue() / 3); 
// 进行两个值的比较 
System.out.println(data1.compareTo(data2)); 
} 
}

3.3333333333333335

–1
La méthode de boxe automatique peut aussi être la suivante :

Vous pouvez également utiliser le java.lang.Number plus général classe pour emballer automatiquement. Par exemple :

int i = 10; 
Integer integer = i;

Number number = 3.14f ;

3.14f sera automatiquement mis en boîte comme Float d'abord, puis attribué au numéro.
À partir de J2SE 5.0, le boxing automatique et le unboxing automatique sont disponibles, c'est-à-dire que les informations de base du formulaire de données dans l'objet sont automatiquement extraites de l'objet. Par exemple, il est possible d'écrire comme suit :

Après que fooInteger soit référencé à une instance qui est automatiquement encadrée comme Integer, si elle est affectée à une variable de type int fooPrimitive, elle deviendra automatiquement une int puis attribué à fooPrimitive. Pendant le fonctionnement, un boxing et un unboxing automatiques peuvent également être effectués. Par exemple :

Integer fooInteger = 10; 
int fooPrimitive = fooInteger;

Dans l'exemple ci-dessus, 20 et 10 seront affichés. Le compilateur effectuera automatiquement la mise en boîte et le déballage, c'est-à-dire que 10 sera d'abord mis en boîte, puis déballé en premier lorsque i 10. , effectuez une opération d'addition ; la ligne i déballe également d'abord, puis effectue une opération d'incrémentation. Regardons un autre exemple :

Integer i = 10; 
System.out.println(i + 10); 
System.out.println(i++);

Boolean boo = true; 
System.out.println(boo && false);

同样的boo原来是Boolean的实例，在进行AND运算时，会先将boo拆箱，再与false进行AND运算，结果会显示false。
//////////////////////////////////////////////////////////////////
装箱：从基本类型转换成Object类型，称之为装箱；***拆箱：从Object转换乘基本类型的操作，称之为拆箱。 这个操作在反射过程中用的比较的多。
装箱：在堆中建立一个Object实例，把你指定的值复制成去；***拆箱：判别引用指向的堆中信息是否是要拆成的类型，是取出堆中值送给栈中变量，否则报异常
///////////////////////////////////////////////////////////////////
装箱是值类型到object类型或到该值类型所实现的任何接口类型的隐士转换。
将一个值类型装箱会分配一个对象实例并将该值复制到新的对象中。

int i=123; 
object o=i;

这句话的结果是在堆栈上创建一个对象o,而该对象在堆上引用int类型的值。该值是赋值给变量i
的值类型值的一个副本。
下面是显示执行装箱转换

int i=123; 
ojbect o=(object)i;

此例将整数变量i通过装箱转换为对象o。这样，存储在变量i中的值就从123改为456。此例显示对象保留了内容的原始副本。即123。
取消装箱是从object类型到值类型或从接口类型到实现该接口的值类型的显示转换。取消装箱操作包括：
检查对象实例，确保它是给定值类型的一个装箱值。
将该值从实例复制到值类型变量中。
例子：

int i=123; 
object box=i; 
int j=(int)box;

更多java自动装箱拆箱深入剖析相关文章请关注PHP中文网！