精华内容
下载资源
问答
  • Java 的自动装箱有很多意想不到的结果,其中有些是广为人知的,这些奇怪的结果多数是 因为自动装箱对象的缓存导致的。
  • 自动装箱 autoBoxing

    万次阅读 2017-05-11 14:23:42
    自动装箱是java 1.5 引入的新技术,主要是为了解决 原始类型和对象的转换, 也就是 原始类型 byte short int long float double boolean char 与 包装对象 Byte Short Integer Long Float Double Boolean ...

    自动装箱是java 1.5 引入的新技术,主要是为了解决 原始类型和对象的转换,
    也就是 原始类型
    byte short int long float double boolean char 与 包装对象
    Byte Short Integer Long Float Double Boolean Character
    的转换。

    1. 什么是自动装箱?
    Integer var1=6;//自动装箱
    Integer var2=6;//自动装箱
    
    if(var1==var2){
    	System.out.println("true");
    }else{
    	System.out.println("false");
    	}
    
    结果输出:true
    
    int var1=6;
    int var2=6;
    if(var1==var2){
    	sysytem.out.println("true");
    }else{
    	system.out.println("false");
    }
    
     结果输出: true
    

    自动装箱的处理代码:

    Integer var1=Integer.valueOf(6);//实际运行代码
    Integer var2=Integer.valueOf(6);//实际运行代码
    
    if(var1==var2){
    	System.out.println("true");
    }else{
    	System.out.println("false");
    	}
    
    输出结果是: true
    

    到目前为止,已经知道了自动装箱是用来把原始数据类型转换成对象。

    2 . 自动装箱的用途:

    赋值和方法调用传递参数。
    自动装箱最常使用的场景是集合,由于集合不能接收原始类型的数据,只接受包装对象。

    List<Integer> integerList=new ArrayList<>();
    integerList.add(1); //autoBox
    integerList.add(2);
    		
    Iterator<Integer> it=integerList.iterator();
    while(it.hasNext()){
    		System.out.println(it.next());
    }
    输出结果:
    1
    2
    

    3 第一个示例遗留的问题,为什么结果是true
    根据我们目前了了解的

    Integer var1=6;//自动装箱
    Integer var2=6;//自动装箱
    

    以上代码创建了对象。 == 在此的意义是判断引用是否相等。

    Integer var1=Integer.valueOf(6);
    Integer var2=Integer.valueOf(6);
    

    valueof 源码

     public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
           
            return new Integer(i);
        }
    

    可以看出两个对象的引用是想等的,因为他们值相同。

    目前我们已经明白了自动装箱的就是用来把原始数据类型变成包装对象。动作的执行者是编译器。

    4.缺点
    自动装箱可以使我们的代码变得简洁,但是没有缺点吗?辩证法来说事物具有两面性。

    Integer count=0;
    for(int i=0;i<1000;i++){
    		count+=i; // 每次循环到这里,都会创建新的对象。
     }
    

    如果出现上面的情况,每次循环到执行 count+=i; 会创建一个对象,这样就会浪费内存,会降低程序性能加重(GC)垃圾回收的工作量。

    这种问题是自动装箱本身引入的问题,因为自动装箱就是把原始类型提升为对象。 我们要在编写代码的时候,尽量避免上面情况的出现。

    展开全文
  • Java AutoBoxing

    2019-11-06 10:12:23
    前言 Android中考虑多态,很多接口的释放会涉及装箱、拆箱,使用中我们是否考虑过如何保证装箱、拆箱过程中数据的一一对应,比如: int i = 10; Object o = i; int rst = (int)o;...如果我们执行:String b = (String...

    前言

    Android中考虑多态,很多接口的释放会涉及装箱、拆箱,使用中我们是否考虑过如何保证装箱、拆箱过程中数据的一一对应,比如:

    int i = 10;
    Object o = i;
    int rst = (int)o;

    如果我们执行:String b = (String)o,会抛出NumberFormatException。这是为什么呢?

    1 装箱、拆箱过程

    当我们执行Intger o = i时,实际调用的是Object o = (Object)Integer.valueOf(i); Object中对应的数据类型value为int;

    当我们执行int rst = (int)o时,实际调用的是int rst = ((Integer)o).intValue(); intValue返回value

    所以如果拆箱时如果目标数据类型与装箱时不匹配,那value类型不对,会抛出NumberFormatException

    2 使用中除了catch NumberFormatException保护外我们还可以怎么做?

    在拆箱前判断if(o.instanceOf(Integer))即可!由其时涉及进程间通信时,在非透明状态下,这层保护尤为重要!!!

    展开全文
  • #自动装箱 ##基本数据类型 #自动拆箱

    前言

    在任何情况下,都不能将对象强制转换成基本数据类型或基本数据类型强制转换为对象。Java中,基本类型和对象是完全不同的东西,不能自动在两者之间强制转换或互换。

    八种基本数据类型对应的包装类

    java.lang包中提供了对应于每种基本数据类型的类:

    基本类型包装类型
    byteByte(父类Number)
    shortShort(父类Number)
    intInteger(父类Number)
    longLong(父类Number)
    floatFloat(父类Number)
    doubleDouble(父类Number)
    booleanBoolean(父类Object)
    charCharachter(父类Object)

    **Number类是抽象类,无法实例化

    一、自动装箱

    自动地将基本数据类型转换为对象
    Byte、Short、Integer、Long、Float、Double、Boolean、Character和Void,这些类被称为对象封装器(object wrapper),因为它们提供了基本类型值的对象表示

    	//创建Integer类来存储100
    	Integer data = new Integer(100);
    

    二、 自动拆箱

    自动地将对象转换为基本数据类型
    Number类中的方法:

    • byte byteValue()
      返回指定数字的值为 byte ,这可能涉及舍入或截断
    • abstract double doubleValue()
      返回指定数字的值为 double ,可能涉及四舍五入
    • abstract float floatValue()
      返回指定数字的值为 float ,可能涉及四舍五入
    • abstract int intValue()
      返回指定数字的值为 int ,这可能涉及舍入或截断
    • abstract long longValue()
      返回指定数字的值为 long ,可能涉及四舍五入或截断
    • short shortValue()
      返回指定数字的值为 short ,这可能涉及舍入或截断
      这些方法负责拆箱
    //从Integer实例获得一个int值
    int dataValue = data.intValue();
    //将String转换为数字类型
    int penn = Integer.parseInt("65000");
    


    展开全文
  • 一、什么是自动装箱和自动拆箱? 自动装箱: Java自动将基本数据类型封装为对象类型。 基本数据类型可以直接赋值给对应的包装类变量。如: Integer i = 100; 本质上是,编译器执行了Integer i = Integer.valueOf...

    一、什么是自动装箱和自动拆箱?

    自动装箱:

    • Java自动将基本数据类型封装为对象类型。
    • 基本数据类型可以直接赋值给对应的包装类变量。如: Integer i = 100;
    • 本质上是,编译器执行了Integer i = Integer.valueOf(100);

    自动拆箱:

    • Java自动将包装类对象转化为基本数据类型
    • 包装类对象可以直接赋值给基本类型变量,如:int a = new Integer(100);
    • 本质上是,编译器编译时为我们添加了:int a = new Integer(100).intValue();
    public class Main {
        public static void main(String[] args) {
        //自动装箱
        Integer x = 100;
        /*
        执行上面代码的时候,系统为我们执行了: 
    	Integer total = Integer.valueOf(100);
        */
    
        //自定拆箱
        Integer integer = new Integer(200);
        int a = integer;
        /*
        执行上面那句代码的时候,系统为我们执行了: 
    	int a = y.intValue();
    	*/
        }
    }
    

    包装类

    由上面可知,直接将八大基本类型的变量表示为对应的类,称为包装类。
    在这里插入图片描述

    二、为什么需要有包装类?

    1. Java中万物皆对象,但八大基本数据类型却不是对象。

    为了使基本数据类型的变量具有对象的特征,引入包装类。
    假设去如下的表中去查询王五的年龄。但是还未录入。如果是int类型的话默认值是0,看起来就有点奇怪,如果是Integer类型的话就为null,表示未录入。
    在这里插入图片描述

    2.为了支持泛型(还有集合)

    public static void main(String[] args) {
    	List<> list1 = new ArrayList<Integer>();//泛型必须是对象类型
    	List<> list2 = new ArrayList<int>();//报错
    } 
    

    3.可以提供了丰富的属性和API

    public static void main(String[] args) {
            System.out.println(Integer.MAX_VALUE);//打印int类型能表示的最大值。输出:2147483647
            System.out.println(Integer.MIN_VALUE);//打印int类型能表示的最小值。输出:-2147483648
            System.out.println(Integer.max(111,222));//找出传入的最大值。输出:222
            System.out.println(Integer.min(111,222));//找出传入的最小值。输出:111
            System.out.println(Integer.sum(111,222));//求和。输出:333
            System.out.println(Integer.valueOf("123"));//将字符串转换为Integer类型 输出:123
            System.out.println(Integer.compare(111,222));//比较大小,第一个参数小于第二个,返回-1。输出:-1
        }
    

    三、包装类的缓存问题

    什么是包装类的缓存

    当通过自动装箱机制创建包装类对象时,首先会判断数值是否在-128—— 127的范围内,如果满足条件,则会从缓存(常量池)中寻找指定数值,若找到缓存,则不会新建对象,只是指向指定数值对应的包装类对象,否则,新建对象。

    public static void main(String[] args) { 
             Integer i1 = 100;
             Integer i2 = 100;
             Integer i3 = 200;
             Integer i4 = 200;
         
             System.out.println(i1==i2); //true
             System.out.println(i3==i4); //false     
    }
    

    使用缓存机制的原因

    缓存的这些对象都是经常使用到的(如字符、-128至127之间的数字),避免重复创建同一对象,节省空间开销和时间消耗,提升了性能。而double、float是浮点型的,没有特别的热的(经常使用到的)数据的,缓存效果没有其它几种类型使用效率高。

    各个包装类缓存值范围

    • boolean:true/false
    • char:0~127
    • byte:-128~127
    • short:-128~127
    • int:-128~127
    • long:-128~127

    特别注意:float和double没有缓存。

    public class Main {
        public static void main(String[] args) {
    
            Double i1 = 100.0;
            Double i2 = 100.0;
            Double i3 = 200.0;
            Double i4 = 200.0;
    
            System.out.println(i1==i2); //false
            System.out.println(i3==i4); //false
        }
    }
    

    补充:

    • 当包装类与基本类型进行“==”运行时,包装类会进行拆箱,拆箱结果与基本类型对比值是否相等;
     Integer num1 = 400;  
     int num2 = 400;  
     System.out.println(num1 == num2); //true
    
    • 两个包装类进行“==”运行时,对比的是两个对象的地址,也即判断是否两个引用是否指向同一个对象。
        Integer x = 200;
        Integer y = 200;
        System.out.println(x==y);//false
    
    展开全文
  • Java 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(autounboxing)是自J2SE 5.0开始提供的功能。java语言规范中说道:在许多情况下包装与解包装是由编译器自行完成的(在这种情况下包装成为装箱,解包装称为...
  • java 5开始引入了autoboxing 和auto-unboxing机制,方便了基本类型和其对应的wrapper类型的转换。比如我们可以直接把一个基本类型的值赋给其wrapper类型,反之亦然;可以把一个基本类型直接放入容器里,封装的过程由...
  • How does autoboxing handle the following code fragment? (自动装箱怎样处理下面的代码片段 ? ) Integer a = null; int b = a; A. It results in a run-time error. Primitive type can store every value of ...
  • Integer是int的封装类,int是基本数据类型 java 5之后提供自动装箱功能,即根据情况装拆箱,装箱Integer.valueOf(),拆箱Integer.intValue() 详细内容
  • 自动装箱(autoboxing

    2017-11-10 11:24:38
    某些时候,主数据类型无法使用,你必须...并且Java5后有autoboxing(自动装箱)为方便人们。 在无autoboxing public void doNumsOldWay(){   ArrayList listOfNumbers = new ArrayList(); //
  • Java的autoboxing

    2017-03-03 15:11:58
    Autoboxing可以转换这些值类型到对应的类。比如int,到Integer, double到Double,boolean到Boolean。collection类如ArrayList,在申明的时候括号里必须是类,如ArrayList array. 不过array 直接可以加
  • [Java]Autoboxing & Unboxing

    千次阅读 2016-05-10 14:20:34
    原文链接:... Autoboxing是java编译器提供的一种从原始类型到对应包装类型(wrapper classes)的自动转换功能。如int转Integer,double转Double等。如果从包装类型转为原始类型,
  • Java的包装类型 对于Java的基本类型都会有默认值,如果数据本身就不存在,直接使用默认值看起来就不那么合适。此时,Java设计的基本数据类型封装成对象的包装类型就能派上用场。 装箱拆箱的类型有哪些?...
  • JDK1.5提供了自动装箱(Autoboxing)和自动拆箱(AutoUnboxing)功能。 所谓自动装箱,就是可以把一个基本类型变量直接赋给对应的包装类变量,或者赋给Object变量(Object类是所有类的父类,子类对象可以直接赋给...
  • 一、什么是自动装箱拆箱很简单,下面两句代码就可以看到装箱和拆箱过程 1 //自动装箱 2 Integer total = 99; 3 4 //自定拆箱 ...简单一点说,装箱就是自动将基本数据类型转换为包装器类型;...这...
  • 基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。  一般我们要创建一个类的对象实例的时候,我们会这样:  Class a = new Class(parameter);  当我们创建一个Integer...
  • 2.Autoboxing和Unboxing是Java语言中基本数据类型的自动装箱、拆箱功能。 => Autoboxing是指基本数据类型和对应的包装类在Java编译器所做的 自动转换 。  例如,编译器将int转换为Integer,将double转换为...
  • 援引 Autoboxing/Unboxing - This facility eliminates the drudgery of manual conversion between primitive types (such as int) and wrapper types (such as Integer). 用法 基本数据类型的自动拆箱和自动装箱 ...
  • 本文将介绍Java的自动装箱与拆箱 翻译自Java官方文档:Autoboxing and Unboxing 什么是自动装箱与拆箱? 什么时候自动装箱? 什么时候自动拆箱?
  • 自动装箱:例如:Integer i = 10; 相当于Integer i = Integer.valueOf(10);自动拆箱:例如:Integer i = 10; int t = i; 相当于int t = i.intValue();引起的陷阱: Integer a1 = 100; Integer b1 = 100;...
  • 1、自动装箱与拆箱的定义 装箱就是自动将基本数据类型转换为包装器类型(int-->Integer); 拆箱就是自动将包装器类型转换为基本数据类型(Integer-->int)。 Java中的数据类型分为两类:一类是基本数据...
  •  Java的Autoboxing的实现机制是在对内置类型对应的类的"="运算符进行了重载,当没有使用new关键字创建对象时,Java就使用Autoboxing方式创建对象,"="重载对应着类的valueOf(parameter) method,parameter为其...
  • 一、什么是自动装箱拆箱  很简单,下面两句代码就可以看到装箱和拆箱过程 1 //自动装箱 2 Integer total = 99; 3 4 //自定拆箱 5 int totalprim = total;...简单一点说,装箱就是自动将基本数据类型转换为包装器...
  • 逐渐挖掘Autoboxing/Auto-Unboxing

    千次阅读 2012-12-13 15:47:13
    J2SE 1.5提供了“Autoboxing”和“Auto-Unboxing”的机制,可以让编译器来自动完成在基本类型和它们的包裹对象之间的转化工作,从而能够用一种更简单的方式,来避免同时存在两套类型系统所带来的一些麻烦。...
  • //no autoboxing Output: method with primitive argument method with wrapper argument 对象相等比较 这是一个比较容易出错的地方,==可以用于原始值进行比较,也可以用于对象进行比较,当用于对象与对象之间比较...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,018
精华内容 2,807
关键字:

autoboxing