精华内容
下载资源
问答
  • Java中自动装箱和拆箱装箱(Boxing),也称为包装(Wrapper),是在对象放置原语类型(primitive type)的过程,以便原语(primitive)可以作为引用对象使用。这里的primitive type就是Java里面的基本类型,所有的基本类型...

    Java中自动装箱和拆箱

    装箱(Boxing),也称为包装(Wrapper),是在对象中放置原语类型(primitive type)的过程,以便原语(primitive)可以作为引用对象使用。

    这里的primitive type就是Java里面的基本类型,所有的基本类型都有一个与之对应的类。例如,Integer类对应基本类型int。

    通常,这些类称为包装器(wrapper)。这些对象包装器类拥有很明显的名字:Integer、Long、Float、Double、Short、Byte、Character、Void和Boolean(前6个类派生于公共的超类Number)。

    对象包装器类是不可变的,即一旦构造了包装器,就不允许更改包装在其中的值。同时,对象包装器类还是final,因此不能定义它们的子类。

    自动装箱是指通过类型转换(隐式或显式)从值类型中获取引用类型,这部分工作是编译器帮我们来完成的。

    我们看一个常见的例子,比如我们创建一个int类型的ArrayList(因为ArrayList的泛型是不允许基本类型的,这里只能使用它们包装类),我们给ArrayList添加元素,再从里面获取元素,一般是这么写的:

    // int类型的自动装箱和拆箱

    ArrayList integerArrayList = new ArrayList<>();

    integerArrayList.add(1);

    int i = integerArrayList.get(0);

    复制代码

    这里分别触发了自动装箱和自动拆箱,这里的add操作触发了一次自动装箱操作,将int转化为Integer;接着从ArrayList里面获取元素,由于我们的目标变量类型是基本类型int,但获取到的元素类型是Integer,所以编译器在这里帮我们做了拆箱的操作。

    通过字节码查看自动装箱和自动拆箱是如何实现的

    我们经常说自动装箱、自动拆箱,到底是如何个自动法,我们来一个眼见为实,通过查看java代码生成的字节码来看下编译器对我们的代码做了什么。

    查看字节码的方式

    这里介绍两种查看字节码的方式:

    第一种,通过javac和javap查看:先通过javac将.java代码编译成.class字节码,然后通过javap分析字节码。

    (base) tinytongtongdeMacBook-Pro% javac TestAutoWrapper.java

    (base) tinytongtongdeMacBook-Pro% javap -verbose TestAutoWrapper

    复制代码

    这样你就能看到你的字节码信息了。

    第二种,通过IDE插件ASM Bytecode Outline来查看,具体操作方式见插件说明。

    查看自动装箱和拆箱的字节码

    public static void main(String[] args) {

    // int类型的自动装箱和拆箱

    ArrayList integerArrayList = new ArrayList<>();

    integerArrayList.add(1);// 自动装箱

    int i = integerArrayList.get(0);// 自动拆箱

    }

    复制代码

    我们生成这段java代码的字节码,核心部分如下:

    // access flags 0x9

    public static main([Ljava/lang/String;)V

    ...

    L1

    LINENUMBER 15 L1

    ALOAD 1

    ICONST_1

    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;

    INVOKEVIRTUAL java/util/ArrayList.add (Ljava/lang/Object;)Z

    POP

    L2

    LINENUMBER 16 L2

    ALOAD 1

    ICONST_0

    INVOKEVIRTUAL java/util/ArrayList.get (I)Ljava/lang/Object;

    CHECKCAST java/lang/Integer

    INVOKEVIRTUAL java/lang/Integer.intValue ()I

    ISTORE 2

    ...

    复制代码

    L1部分中的倒数第二行,INVOKEVIRTUAL java/util/ArrayList.add (Ljava/lang/Object;)Z,INVOKEVIRTUAL指令表示一个虚方法调用,这里具体就是我们java代码中的integerArrayList.add(1);,自动装箱发生在哪呢?就在它上面,INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;,INVOKESTATIC表示静态方法调用,这里对应的Java语句就是Integer#valueOf()方法。

    接下来我们看下自动装箱对应的字节码,也就是L2部分,先看INVOKEVIRTUAL java/util/ArrayList.get (I)Ljava/lang/Object;,它对应的java代码是integerArrayList.get(0),表示从ArrayList里面获取到Integer类型对象。自动拆箱发生在下面,就是NVOKEVIRTUAL java/lang/Integer.intValue ()I这条指令,它对应的java方法是Integer#intValue()方法。

    看到这里相信大家对自动装箱和拆箱有一个比较具体的认识了,说白了就是编译器会根据情况替我们做一些工作,通过插入字节码指令来替我们完成装箱和拆箱操作。int对应的装箱方法是Integer#valueOf,拆箱方法是Integer#intValue()。

    自动装箱和拆箱的触发时机

    我们接着讲下自动装箱和拆箱的触发时机,具体如下:

    * 进行 = 赋值操作(装箱或拆箱)

    * 进行+,-,*,/混合运算 (拆箱)

    * 进行>,

    * 调用equals进行比较(装箱)

    * ArrayList,HashMap等集合类 添加基础类型数据时(装箱)

    复制代码

    基本类型自动装箱和拆箱方法总结

    基本类型包装类型装箱方法拆箱方法intIntegerInteger#valueOf()Integer#intValue()

    longLongLong.valueOf()Long.longValue()

    byteByteByte.valueOf()Byte.byteValue()

    shortShortShort.valueOf()Short.shortValue()

    floatFloatFloat.valueOf()Float.floatValue()

    doubleDoubleDouble.valueOf()Double.doubleValue()

    charCharacterCharacter.valueOf()Character.charValue()

    booleanBooleanBoolean.valueOf()Boolean.booleanValue()

    感兴趣的同学可以自己试下各种操作下,自动装箱和拆箱的表现,查看对应的字节码即可。

    参考

    展开全文
  • 主要给大家介绍了关于Java中自动装箱拆箱引起的耗时的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • java中自动装箱和拆箱 Java中自动装箱和拆箱 (Autoboxing and Unboxing in Java) In Java 1.5, Java added concept of autoboxing and unboxing that deal with conversion of primitive type to object and vice...

    java中自动装箱和拆箱

    In Java 1.5, Java added concept of autoboxing and unboxing that deal with conversion of primitive type to object and vice versa.

    在Java 1.5中,Java添加了自动装箱和拆箱的概念,用于处理从原始类型到对象的转换,反之亦然。

    The term autoboxing refers to the auto conversion of primitive type to its correspond object type. For example, conversion of int type to Integer object or char type to Character object. This conversion is done implicitly by the Java compiler during program execution.

    术语自动装箱是指将原始类型自动转换为其对应的对象类型。 例如,将int类型转换为Integer对象或将char类型转换为Character对象。 Java编译器在程序执行期间隐式完成了此转换。

    In the same context, when an object coverts to its correspond primitive type then it is called unboxing. For example, conversion of Integer type to int type or Byte to byte type etc. Java automatically performs this conversion during program execution.

    在相同的上下文中,当一个对象隐蔽为其对应的原始类型时,则称为拆箱 。 例如,将Integer类型转换为int类型或将Byte转换为字节类型等。Java在程序执行期间自动执行此转换。

    自动装箱示例 (Example of Autoboxing)

    In this example, we are assigning an int type value to Integer object and notice compiler does not report any error because it performs autoboxing here.

    在此示例中,我们为Integer对象分配了一个int类型值,并且注意编译器不会报告任何错误,因为它在此处执行自动装箱。

    class Demo
    {
    	public static void main(String[] args)
    	{
    		Integer i = 100; // Auto-boxing of int i.e converting primitive data type int to a Wrapper class Integer
    		System.out.println(i);
    
    		Character ch = 'a'; 
    		System.out.println(ch);
    		
    		Byte b = 12;
    		System.out.println(b);
    		
    	}
    }

    100 a 12

    100一12

    说明: (Explanation:)

    Whenever we use object of Wrapper class in an expression, autoboxing is done by JVM.

    每当我们在表达式中使用Wrapper类的对象时,自动装箱便由JVM完成。

    This will happen always, when we will use Wrapper class objects in expressions or conditions etc.

    当我们在表达式或条件等中使用Wrapper类对象时,这总是会发生的。

    示例:集合中的自动装箱 (Example: Autoboxing in Collection)

    import java.util.ArrayList;
    
    class Demo
    {
    	public static void main(String[] args)
    	{
    		ArrayList<Integer> arrayList = new ArrayList<Integer>();
    		arrayList.add(100); // autoboxing int to Integer
    		arrayList.add(200);
    		arrayList.add(300);
    		for(Integer i : arrayList) {
    			System.out.println(i);
    		}
    	}
    }

    100 200 300

    100200300

    In the same manner, we can perform unboxing. Lets see an example.

    以相同的方式,我们可以执行拆箱。 让我们来看一个例子。

    示例:拆箱 (Example : Unboxing)

    In this example, we using arraylist to store int type values. Since arraylist stores only object then it automatically converts int type to Integer and store the elements. If we fetch the elements of it returns object type and if we store it into primitive int type then it automatically converts Integer to int type. See the below example.

    在此示例中,我们使用arraylist存储int类型值。 由于arraylist仅存储对象,因此它将自动将int类型转换为Integer并存储元素。 如果获取它的元素,则返回对象类型,如果将其存储为原始int类型,则它将自动将Integer转换为int类型。 请参见以下示例。

    import java.util.ArrayList;
    
    class Demo
    {
    	public static void main(String[] args)
    	{
    		ArrayList
       
         arrayList = new ArrayList
        
         ();
    		arrayList.add(100); // autoboxing int to Integer
    		arrayList.add(200);
    		arrayList.add(300);
    		for(Integer i : arrayList) {
    			System.out.println(i);
    		}
    		// unboxing Integer to int type
    		int first = arrayList.get(0);
    		System.out.println("int value "+first);
    	}
    }
    	
        
       

    100 200 300 int value 100

    100200300整数值100

    自动装箱/拆箱的好处 (Benefits of Autoboxing / Unboxing)

    1. Autoboxing / Unboxing lets us use primitive types and Wrapper class objects interchangeably.

      自动装箱/拆箱使我们可以互换使用原始类型和Wrapper类对象。

    2. We don't have to perform Explicit typecasting.

      我们不必执行显式类型转换

    3. It helps prevent errors, but may lead to unexpected results sometimes. Hence must be used with care.

      它有助于防止错误,但有时可能会导致意外结果。 因此,必须谨慎使用。

    4. Auto-unboxing also allows you to mix different types of numeric objects in an expression. When the values are unboxed, the standard type conversions can be applied.

      自动拆箱还允许您在表达式中混合使用不同类型的数字对象。 将值取消装箱后,可以应用标准类型转换。

    例: (Example:)

    class Demo {
    	public static void main(String args[]) {
    		Integer i = 35;
    		Double d = 33.3;
    		d = d + i;
    		System.out.println("Value of d is " + d);
    	}
    }

    Value of d is 68.3

    d的值是68.3

    Note: When the statement d = d + i; was executed, i was auto-unboxed into int, d was auto-unboxed into double, addition was performed and then finally, auto-boxing of d was done into Double type Wrapper class.

    注意:当语句d = d + i时; 执行后,我被自动拆箱为int,将d自动拆箱为double,执行了加法运算,最后将d的自动装箱完成为Double type Wrapper类。

    类型包装纸 (Type Wrappers)

    Java uses primitive data types such as int, double, float etc. to hold the basic data types for the sake of performance. Despite the performance benefits offered by the primitive data types, there are situations when you will need an object representation of the primitive data type. For example, many data structures in Java operate on objects. So you cannot use primitive data types with those data structures. To handle such type of situations, Java provides type Wrappers which provide classes that encapsulate a primitive type within an object.

    为了性能起见,Java使用原始数据类型(例如int,double,float等)来保存基本数据类型。 尽管原始数据类型提供了性能上的好处,但是在某些情况下,您仍然需要原始数据类型的对象表示。 例如,Java中的许多数据结构都对对象进行操作。 因此,不能将原始数据类型与这些数据结构一起使用。 为了处理这种情况,Java提供了类型包装器 ,该包装器提供了将对象中的原始类型封装起来的类。

    Java provides wrapper classes correspond to each primitive type to deal with objects that are tabled below.

    Java提供了与每种基本类型相对应的包装器类,以处理下表中列出的对象。

    PrimitiveWrapper class
    intInteger
    byteByte
    shortShort
    floatFloat
    doubleDouble
    charCharacter
    longLong
    booleanBoolean
    原始 包装类
    整型 整数
    字节 字节
    浮动 浮动
    烧焦 字符
    布尔值 布尔型

    Above mentioned Classes comes under Numeric type wrapper. These classes encapsulate byte, short, int, long, float, double primitive type.

    上面提到的类在数字类型包装器下。 这些类封装了byte,short,int,long,float,double基本类型。

    示例:方法中的自动装箱和拆箱 (Example: Autoboxing and Unboxing in method)

    We can see how autoboxing and unboxing take place in a method. Notice, during method call we passed int type primitive value but method accepts only Integer objects so here JVM does autoboxing implicitly. And notice, this method returns an int type primitive which is another conversion (unboxing) from Integer to int type.

    我们可以看到自动装箱和拆箱的方法。 注意,在方法调用期间,我们传递了int类型的原始值,但是方法仅接受Integer对象,因此JVM在此隐式进行自动装箱。 请注意,此方法返回一个int类型原语,这是从Integer到int类型的另一种转换(拆箱)。

    class Demo {
    	// autoboxing in parameters
    	static int add(Integer a, Integer b) {
    		// unboxing in return
    		return a+b;
    	}
    	
    	public static void main(String args[]) {
    		
    		int sum = add(10,20);
    		
    		System.out.println("sum = "+sum);
    		
    		}
    }

    sum = 30

    总和= 30

    翻译自: https://www.studytonight.com/java/autoboxing-unboxing-java.php

    java中自动装箱和拆箱

    展开全文
  • Java中自动装箱拆箱

    2021-03-06 04:21:28
    Java中自动装箱拆箱一、自动装箱与自动拆箱自动装箱就是将基本数据类型转换为包装类类型,自动拆箱就是将包装类类型转换为基本数据类型。1 //自动装箱2 Integer total = 90;34 //自动拆箱5 int totalprim = total;...

    Java中的自动装箱拆箱

    一、自动装箱与自动拆箱

    自动装箱就是将基本数据类型转换为包装类类型,自动拆箱就是将包装类类型转换为基本数据类型。

    1 //自动装箱

    2 Integer total = 90;3

    4 //自动拆箱

    5 int totalprim = total;

    以 整数型 Integer 为例 ,从上面代码分析:装箱与拆箱的过程

    (一)、自动装箱

    total声明的是包装类型Integer,数值90是数据常量,当执行Integer total = 90时,系统为我们执行了Integer total = Integer.valueOf(99);

    首先看一下:valueOf(int i)方法源码:IntegerCache.low = -128,IntegerCache.high = 127,IntegerCache.cache[ ]是Integer类型的数组

    e006183e05bc9c577869d1c08ed7da9f.png

    首先判断 i 的大小:如果 i =< -128或者i  >= 127,否则就创建一个Integer对象,否则返回 IntegerCache.cache[i + 128];

    然后再看Integer的构造方法:

    623b5459f5b2290bac6302e0eb626301.png

    084229b49e262985ae9ca6db3a67086f.png

    Integer定义了 一个  private final int value; 当创建一个Integer对象,就会给这个变量初始化。第二个构造方法传入的是一个String变量,它会先把它转换成一个int值,然后进行初始化。

    IntegerCache.cache[ ]数组是 Integer 的内部类,定义了 static final Integer cache[]; 它是一个静态的Integer数组对象,也就是说最终valueOf返回的都是一个Integer对象。

    所以我们这里可以总结一点:装箱的过程会创建对应的对象,这个会消耗内存,所以装箱的过程会增加内存的消耗,影响性能。

    (二)、自动拆箱

    totalprim 声明的基本数据类型 int,total 是 包装类型 Integer ,当执行 int totalprim = total时,系统会自动调用 intValue()方法。首先看一下intValue方法:

    7ac19074e297871c954b3b6ebf26d83c.png

    intValue方法较简单,直接返回 value 的值。

    二、相关问题

    自动装箱时,分别有两种情况:

    1、i >= 128 || i < -128 =====> new Integer(i)

    2、i < 128 && i >= -128 =====> IntegerCache.cache[i + 128]

    IntegerCache.cache[ ] 是Integer 的内部类中定义的数组对象,本来已经创建好了,也就是说在i >= 128 || i < -128是会创建不同的对象,在i < 128 && i >= -128会根据 i 的值返回已经创建好的指定的对象。

    举个例子:

    91e56df1d912159e5a5d626bfd8c4f1a.png

    通过执行上面的代码,分别输出了 true 和 false,数值一样,结果却不同,这是为什么呢?

    ①、i1 和 i1 都赋值为100,属于自动装箱的第二种情况,所以返回的是IntegerCache.cache[ ]数组中的对象,由于引用的是同一个 Integer 对象,所以他们的地址值是相等的,即他们是相等的。

    ②、i3 和 i4 都赋值为200,属于自动装箱的第一种情况,valueOf 方法会生成新的对象并返回,由于是分别引用的对象,两个对象的地址值不同,所以 “==” 判断时,他们是不相等的。

    三、浮点型和布尔型的装箱拆箱

    (一)、浮点型

    9ae734815e22dbac817960a0fd9d4182.png

    数值相同,结果和 Integer 不同 ,和 Integer 类似,当调用 Double d1 = 100.0 时,系统会调用valueOf(double d),首先看一下源码 :

    f0a5ab0a185d6e80d599ada7a66b4a15.png

    每次调用 valueOf 方法时,都会新生成一个 Double 对象 ,所以他们引用对象的地址值都不一样,因为 Integer 内部维护了一个IntegerCache.cache[ ] ,而IntegerCache.cache[ ]对象在整数型中的长度是固定的,所以在满足范围时返回的是同一个引用对象;而浮点型数据范围是无限大的,定义数组不太现实,所以直接生成新的对象。

    (二)、布尔型

    d23939373ec216dc622538fe8531c7b1.png

    可以看到返回的都是true,也就是它们执行valueOf返回的都是相同的对象。和上面类似,当调用 Boolean b1 = false 时,系统会调用valueOf(boolean b),首先看一下源码 :

    f0aaf64c94a28680bc93fa22001343ea.png

    可以看到它并没有创建对象,因为在内部已经提前创建好两个常量,因为它只有两种情况,这样也是为了避免重复创建太多的对象。

    (三)、小结

    整数型派别:Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。

    浮点数型派别:Double、Float的valueOf方法的实现是类似的。每次都返回不同的对象。

    四、基础数据类型与包装类进行 ==、+、-、*、/ 运算

    (一)运算

    当基本数据类型进行普通的运算时,直接进行运算。

    当包装类进行运算时,会先将包装类拆箱成基本数据类型,然后进行运算。

    (二)、equals与 “==” 比较

    包装类型重写了 Object 的 equal 方法,equal 比较的是内容本身,并且我们也可以看到equal的参数是一个Object对象,我们传入的是一个int类型,所以首先会进行装箱,然后比较对象里面的value值。

    “==”运算符的两个操作数如果都是包装类类型的引用,则是比较指向的是否是同一个对象,而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。

    五、总结

    装箱操作会创建对象,频繁的装箱操作会消耗许多内存,影响性能,所以可以避免装箱的时候应该尽量避免。

    equals(Object o) 因为原equals方法中的参数类型是封装类型,所传入的参数类型(a)是原始数据类型,所以会自动对其装箱,反之,会对其进行拆箱

    当两种不同类型用==比较时,包装器类的需要拆箱, 当同种类型用==比较时,会自动拆箱或者装箱

    展开全文
  • Java中自动装箱和拆箱 装箱(Boxing),也称为包装(Wrapper),是在对象放置原语类型(primitive type)的过程,以便原语(primitive)可以作为引用对象使用。 这里的primitive type就是Java里面的基本类型,...

    Java中自动装箱和拆箱

    装箱(Boxing),也称为包装(Wrapper),是在对象中放置原语类型(primitive type)的过程,以便原语(primitive)可以作为引用对象使用。

    这里的primitive type就是Java里面的基本类型,所有的基本类型都有一个与之对应的类。例如,Integer类对应基本类型int。

    通常,这些类称为包装器(wrapper)。这些对象包装器类拥有很明显的名字:Integer、Long、Float、Double、Short、Byte、Character、Void和Boolean(前6个类派生于公共的超类Number)。

    对象包装器类是不可变的,即一旦构造了包装器,就不允许更改包装在其中的值。同时,对象包装器类还是final,因此不能定义它们的子类。

    自动装箱是指通过类型转换(隐式或显式)从值类型中获取引用类型,这部分工作是编译器帮我们来完成的。

    我们看一个常见的例子,比如我们创建一个int类型的ArrayList(因为ArrayList的泛型是不允许基本类型的,这里只能使用它们包装类),我们给ArrayList添加元素,再从里面获取元素,一般是这么写的:

    // int类型的自动装箱和拆箱
    ArrayList<Integer> integerArrayList = new ArrayList<>();
    integerArrayList.add(1);
    int i = integerArrayList.get(0);

    这里分别触发了自动装箱和自动拆箱,这里的add操作触发了一次自动装箱操作,将int转化为Integer;接着从ArrayList里面获取元素,由于我们的目标变量类型是基本类型int,但获取到的元素类型是Integer,所以编译器在这里帮我们做了拆箱的操作。

    通过字节码查看自动装箱和自动拆箱是如何实现的

    我们经常说自动装箱、自动拆箱,到底是如何个自动法,我们来一个眼见为实,通过查看java代码生成的字节码来看下编译器对我们的代码做了什么。

    查看字节码的方式

    这里介绍两种查看字节码的方式: 第一种,通过javac和javap查看:先通过javac将.java代码编译成.class字节码,然后通过javap分析字节码。

    (base) tinytongtongdeMacBook-Pro% javac TestAutoWrapper.java
    (base) tinytongtongdeMacBook-Pro% javap -verbose TestAutoWrapper

    这样你就能看到你的字节码信息了。

    第二种,通过IDE插件ASM Bytecode Outline来查看,具体操作方式见插件说明。

    查看自动装箱和拆箱的字节码

    public static void main(String[] args) {
        // int类型的自动装箱和拆箱
        ArrayList<Integer> integerArrayList = new ArrayList<>();
        integerArrayList.add(1);// 自动装箱
        int i = integerArrayList.get(0);// 自动拆箱
    }

    我们生成这段java代码的字节码,核心部分如下:

    // access flags 0x9
      public static main([Ljava/lang/String;)V
       ...
       L1
        LINENUMBER 15 L1
        ALOAD 1
        ICONST_1
        INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
        INVOKEVIRTUAL java/util/ArrayList.add (Ljava/lang/Object;)Z
        POP
       L2
        LINENUMBER 16 L2
        ALOAD 1
        ICONST_0
        INVOKEVIRTUAL java/util/ArrayList.get (I)Ljava/lang/Object;
        CHECKCAST java/lang/Integer
        INVOKEVIRTUAL java/lang/Integer.intValue ()I
        ISTORE 2
       ...

    L1部分中的倒数第二行,INVOKEVIRTUAL java/util/ArrayList.add (Ljava/lang/Object;)ZINVOKEVIRTUAL指令表示一个虚方法调用,这里具体就是我们java代码中的integerArrayList.add(1);,自动装箱发生在哪呢?就在它上面,INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;INVOKESTATIC表示静态方法调用,这里对应的Java语句就是Integer#valueOf()方法。

    接下来我们看下自动装箱对应的字节码,也就是L2部分,先看INVOKEVIRTUAL java/util/ArrayList.get (I)Ljava/lang/Object;,它对应的java代码是integerArrayList.get(0),表示从ArrayList里面获取到Integer类型对象。自动拆箱发生在下面,就是NVOKEVIRTUAL java/lang/Integer.intValue ()I这条指令,它对应的java方法是Integer#intValue()方法。

    看到这里相信大家对自动装箱拆箱有一个比较具体的认识了,说白了就是编译器会根据情况替我们做一些工作,通过插入字节码指令来替我们完成装箱和拆箱操作。int对应的装箱方法是Integer#valueOf,拆箱方法是Integer#intValue()

    自动装箱和拆箱的触发时机

    我们接着讲下自动装箱和拆箱的触发时机,具体如下:

    * 进行 = 赋值操作(装箱或拆箱)
    * 进行+,-,*,/混合运算 (拆箱)
    * 进行>,<,==比较运算(拆箱)
    * 调用equals进行比较(装箱)
    * ArrayList,HashMap等集合类 添加基础类型数据时(装箱)

    基本类型自动装箱和拆箱方法总结

    基本类型包装类型装箱方法拆箱方法
    intIntegerInteger#valueOf()Integer#intValue()
    longLongLong.valueOf()Long.longValue()
    byteByteByte.valueOf()Byte.byteValue()
    shortShortShort.valueOf()Short.shortValue()
    floatFloatFloat.valueOf()Float.floatValue()
    doubleDoubleDouble.valueOf()Double.doubleValue()
    charCharacterCharacter.valueOf()Character.charValue()
    booleanBooleanBoolean.valueOf()Boolean.booleanValue()

    感兴趣的同学可以自己试下各种操作下,自动装箱和拆箱的表现,查看对应的字节码即可。

    展开全文
  • 自动装箱和拆箱Java 1.5开始引入,目的是将原始类型值转自动地转换成对应的对象。自动装箱拆箱的机制可以让我们在Java的变量赋值或者是方法调用等情况下使用原始类型或者对象类型更加简单直接。 如果你在Java...
  • 本篇文章主要介绍了详解Java 自动装箱拆箱的实现原理,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java中装箱和拆箱

    2021-03-13 22:45:24
    一、什么是装箱和拆箱JAVA中基本数据类型与它们的包装类进行运算时,编译器会自动帮我们进行转换,转换过程是透明的。其中,装箱就是自动将基本数据类型转换为包装器类型;拆箱就是自动将包装器类型转换为基本数据...
  • 自动装箱和拆箱问题是Java中一个老生常谈的问题了,我们来一些看一下装箱和拆箱中的若干问题。本文先讲述装箱拆箱基本的东西,再来看一下面试笔试中经常遇到的与装箱、拆箱相关的问题。  以下是本文的目录大纲:...
  • java语言从1.5之后,可以自动将原始类型与对象进行相互转换,不用编程转换,被称为自动装箱和拆箱。将原始类型转换为对象称为自动装箱,例如将int转换为Integer,将对象转换为原始类称为自动拆箱,例如将Integer转换...
  • 一、装箱概念 ...说明:java5以后实现了自动装箱功能,会自动根据数值创建对应的 Integer对象,这就是装箱。 二、拆箱 把integer对象类型变为int基本数据类型就是拆箱。 Integer i = 10; //装箱 ...
  • Java自动装箱和拆箱的实现原理

    千次阅读 2019-10-02 10:02:31
    一、装箱和拆箱 原始类型转换为对象类型就是装箱,反之就是拆箱。 原始类型byte,short,char,int,long,float,double,...自动装箱时编译器调用valueOf将原始类型值转换成对象,同时自动拆箱时,编译器通过调用类似intV...
  • 基元与类Java中的原始变量包含值(整数,双精度浮点二进制数等)。因为这些值可能具有不同的长度,所以包含它们的变量也可能具有不同的长度(考虑float对比double)。另一方面,类变量包含对实例的引用。引用通常在许多...
  • java中装箱拆箱

    2021-03-09 22:57:35
    什么是自动装箱拆箱基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。一般我们要创建一个类的对象实例的时候,我们会这样:Class a = new Class(parameter);当我们创建一个Integer...
  •   自动装箱和自动拆箱是两个相反的过程,自动装箱即将基本数据类型转换为对应的封装类,自动拆箱即将封装类转换为对应的基本数据类型。此外,装箱的过程会增加内存的消耗,影响性能,因为这个过程会创建对应的对象...
  • 自动装箱和拆箱Java 1.5开始引入,目的是将原始类型值转自动地转换成对应的对象。自动装箱拆箱的机制可以让我们在Java的变量赋值或者是方法调用等情况下使用原始类型或者对象类型更加简单直接。  如果你在Java...
  • Java自动装箱与自动拆箱(包装类)

    千次阅读 多人点赞 2019-06-15 10:18:39
    包装类的作用: Java 语言,一切都是对象,但是有例外: 8 个基本数据类型不是对象,因此在很多时候非常不方便。 为此, Java提供为 8 个基本类型提供了对应的包装类: byte ------- Byte short ------ Short ....
  • 1、什么是自动装箱拆箱 很简单,下面两句代码就可以看到bai装箱拆箱过程 //自动装箱 Integertotal=99; //自定拆箱 inttotalprim=total; 简单一点说,装箱就是自动将基本数据类型转换为包装器类型;拆箱就是...
  • Java中装箱和拆箱

    2020-05-20 10:11:18
    自动装箱和拆箱问题是java面试基础题出现频率很高,好记性不如烂笔头,把之前遇到的相关问题概念做一下记录 包装类 Java中包含8种基本数据类型,并且在java5之后,为每种基本数据类型都提供了对应的包装器类型...
  • java自动装箱和拆箱

    2019-06-12 15:18:25
    https://www.cnblogs.com/wang-yaz/p/8516151.html
  • 自动装箱和拆箱问题是Java中一个老生常谈的问题了,今天我们就来一些看一下装箱和拆箱中的若干问题。本文先讲述装箱拆箱最基本的东西,再来看一下面试笔试中经常遇到的与装箱、拆箱相关的问题。一.什么是装箱?...
  • 一、前言Java自动装箱和自动拆箱是JDK5.0版本提供的新特性,所以在JDK5.0后的版本中都可以使用,之前的版本则不支持该特性。理解自动装箱自动拆箱需要先对java的8种原始数据类型相对应的封装类有所了解。二、8...
  • java基础--06(自动装箱拆箱

    万次阅读 多人点赞 2019-02-11 16:40:27
    1.自动装箱,自动拆箱 1.自动装箱,自动拆箱 装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。 java的数据类型: 自动装箱: 最主要的就是Integer b=a;这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,298
精华内容 16,519
关键字:

java中自动装箱和拆箱

java 订阅