精华内容
下载资源
问答
  • Java包装类

    2019-02-25 17:14:46
    Java包装类 java中的包装类提供了将原始数据类型转换为对象,以及将对象转换为原始数据类型的机制。是为了把原始数据当做对象进行操作; 八个包装类 基本类型 包装类 boolean Boolean char Character ...

    Java包装类


    java中的包装类提供了将原始数据类型转换为对象,以及将对象转换为原始数据类型的机制。是为了把原始数据当做对象进行操作;
    八个包装类

    基本类型包装类
    booleanBoolean
    charCharacter
    byteByte
    shortShort
    intInteger
    longLong
    floatFloat
    doubleDouble
    展开全文
  • 包装类拆箱和装箱(自动)基本数据类型和字符串之间的转换 一.BigInteger类 概念 操作整数  我们都知道4类8种中整数最大的类型是:long  我们以后遇到的数字,有可能会超过long的取值范围,long就接收不了这么大的...
  • int d = 128; /* * 基本类型转换为包装类java推荐我们使用 * 包装类的静态方法valueOf. */ Integer i1 = Integer.valueOf(d); Integer i2 = Integer.valueOf(d); System.out...

    int d = 128;
            /*
             * 基本类型转换为包装类java推荐我们使用
             * 包装类的静态方法valueOf.
             */
            Integer i1 = Integer.valueOf(d);
            Integer i2 = Integer.valueOf(d);    
            System.out.println(i1==i2);//false
            System.out.println(i1.equals(i2));//true
            ==判断的是引用是否是同一个引用

    equals判断的是是否值相同

    Integer.valueOf(int)将基本类型int转为包装类

    Double.valueOf(double)同样是将基本类型double转为包装类

    int i = i1.intValue();
            System.out.println(i);

    intValue()是将包装类转为基本类型int

        Double d3=Double.valueOf(0.38);
            double dou = d3.doubleValue();
            System.out.println(dou);

    double.Value()将包装类转为基本类型double

    包装类有静态常量int imax =Integer.MAX_VALUE;

    int imin = Integer.MIN_VALUE;

    MAX_VALUE

    MIN_VALUE

    String str = "123";
            int d = Integer.parseInt(str);

    包装类静态方法字符串转为对应数字,基本类型

        double dou = Double.parseDouble(str);

    int a = 1;
            /*
             * 这里触发了自动装箱特性,编译器在编译时
             * 会将代码改为:
             * Integer i = Integer.valueOf(a);
             * 将基本类型转换为包装类.
             */
            Integer i = a;
            /*
             * 下面代码触发了自动拆箱特性,编译器会改为:
             * a = i.intValue();
             * 将包装类转换为对应的基本类型
             */
            a = i;
            System.out.println(a);

     

     

    展开全文
  • 深入理解Java包装类与自动拆装箱

    千次阅读 2020-06-21 22:36:30
    你真的理解Java包装类和自动拆装箱吗?有些知识你绝对不知道!

    在Java中,针对八种基本数据类型定义了相应的引用类型—包装类(封装类)
    有了类的特点,就可以调用类中的方法,Java才是真正的面向对象。

    八种基本数据类型对应的包装类如下图所示:
    在这里插入图片描述
    基本数据类型与包装类之间的转换,如下图所示:
    在这里插入图片描述

    一、基本数据类型转换为包装类

    在这里插入图片描述
    基本数据类型—>包装类:调用包装类的构造器

    //基本数据类型——>包装类:调用包装类的构造器
    int i=10;
    Integer integer=new Integer(i);
    System.out.println(integer.toString()); //10  toString可加可不加
    Integer integer1=new Integer("123");
    System.out.println(integer1); //123
    Integer integer2=new Integer("123abc"); // ×
    
    double d1=12.3;
    Double d2=new Double(d1);
    System.out.println(d2); //12.3
    
    float f1=123.45F;
    Float f2=new Float(f1);
    System.out.println(f2); //123.45
    
    char c1='A';
    Character c2=new Character(c1);
    System.out.println(c2); //A
    
    boolean b1=true;
    Boolean b2=new Boolean(b1);
    System.out.println(b2); //true
    Boolean b3=new Boolean("TruE"); //可以忽略大小写
    System.out.println(b3); //true
    
    //注意点:包装类是类,默认初始化值为null
    Class Order{
        int i1;
        Integer i2;
        double d1;
        Double d2;
        boolean b1;
        Boolean b2;
    }
    
    public class Test {
        public static void main(String[] args) {
            Order order=new Order();
            System.out.println(order.i1); //0
            System.out.println(order.i2); //null 包装类是类,默认初始化值为null
            System.out.println(order.d1); //0.0
            System.out.println(order.d2); //null 
            System.out.println(order.b1); //false
            System.out.println(order.b2); //null
        }
    }
    

    总结:包装类是类,默认初始化值为null

    二、包装类转换为基本数据类型

    在这里插入图片描述
    包装类—>基本数据类型:调用包装类的xxxValue()方法

    //包装类——>基本数据类型:调用包装类的xxxValue()方法
    Integer integer=new Integer(12);
    int i=integer.intValue();
    System.out.println(i); //12
    
    byte b=integer.byteValue();
    System.out.println(b); //12
    
    short s=integer.shortValue();
    System.out.println(s); //12
    
    long l=integer.longValue();
    System.out.println(l); //12
    
    double d=integer.doubleValue();
    System.out.println(d); //12.0
    
    float f=integer.floatValue();
    System.out.println(f); //12.0
    
    Double d1=new Double("12.3");
    double d2=d1.doubleValue();
    System.out.println(d2); //12.3
    
    Float f1=new Float("12.6");
    float f2=f1.floatValue();
    System.out.println(f2); //12.6
    
    //总结:byte、short、int、long、float、double,它们的包装类都可以装换成这六种基本数据类型
    
    Boolean b1=new Boolean("true");
    boolean b2=b1.booleanValue();
    System.out.println(b2); //true
    
    Character c1=new Character('A');
    char c2=c1.charValue();
    System.out.println(c2); //A
    

    总结:包装类——>基本数据类型:调用包装类的xxxValue()方法;
    byte、short、int、long、float、double,它们的包装类都可以装换成这六种基本数据类型。

    三、自动拆装箱

    自动装箱和拆箱是从Java 1.5开始引入的,目的是将原始类型值转自动地转换成对应的包装类(对象)。自动装箱与拆箱的机制可以让我们在Java的变量赋值或者是方法调用等情况下使用原始类型或者对象类型更加简单直接。

    3.1 自动装箱

    如果基本数据类型的数据处于需要对象的环境中时,会自动转为“对象”。
    自动装箱过程是通过调用包装类的valueOf()方法实现的。

    Integer i = 100; //自动装箱
    //相当于编译器自动作以下的语法编译:
    Integer i = Integer.valueOf(100); //调用的是valueOf(100),不是new Integer(100)
    

    3.2 自动拆箱

    如果包装类对象处于需要基本数据类型的环境中时,包装类对象会自动转成基本数据类型,没必要再去显式调用intValue()、doubleValue()等转型方法。

    Integer i = 100;
    int k = i;//自动拆箱
    //相当于编译器自动作以下的语法编译:
    int k = i.intValue();
    

    3.3 包装类的缓存问题

    整型、char类型所对应的包装类,在自动装箱时,对于-128~127之间的值会进行缓存处理,其目的是提高效率。
    缓存处理的原理为:如果数据在-128~127这个区间,那么在类加载时就已经为该区间的每个数值创建了对象,并将这256个对象存放到一个名为cache的数组中。每当自动装箱过程发生时(或者手动调用valueOf()时),就会先判断数据是否在该区间,如果在则直接获取数组中对应的包装类对象的引用,如果不在该区间,则会通过new的方式调用包装类的构造方法来创建对象。
    Integer类相关源码:

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

    IntegerCache类相关源码:

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
    
        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
    
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
    
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
    
        private IntegerCache() {}
    }
    

    由上面的源码我们可以看出:

    1. IntegerCache类为Integer类的一个静态内部类,仅供Integer类使用。
    2. 一般情况下 IntegerCache.low为-128,IntegerCache.high为127,IntegerCache.cache为内部类的一个静态属性。
    3. 静态代码块的目的就是初始化数组cache的,这个过程会在类加载时完成。

    3.4 自动拆装箱注意问题

    3.4.1 空指针异常问题

    自动装箱与拆箱的功能是所谓的“编译器蜜糖(Compiler Sugar)”,虽然使用这个功能很方便,但在程序运行阶段必须了解Java的语义。
    例如下面的程序是可以通过编译的:

    public class Test {
        public static void main(String[] args) {
            Integer i = null; //因为Integer是类,所以值可以为null
            int j = i;
        }
    }
    

    运行结果:
    在这里插入图片描述
    运行结果之所以会出现空指针异常,是因为上述的代码相当于:

    public class Test {
        public static void main(String[] args) {
            Integer i = null; 
            int j = i.intValue();   
        }
    }
    
    3.4.2 使用==进行比较时(重点)

    这是一个比较容易出错的地方,== 既可以用于数值进行比较,也可以用于对象进行比较。当用于对象与对象之间比较时,比较的不是对象代表的值,而是检查两个对象是否是同一对象,这个比较过程中不会发生自动装箱。如果想要进行对象值比较,不应该使用==,而应该使用对象对应的equals方法。

    下面我们使用例子来进行说明:

    //建议:先自己写答案,再看运行结果,看运行结果与你的答案是否一致
    public class Test {
        public static void main(String[] args) {
            int int1 = 10;
            int int2 = 10;
    
            Integer integer1 = new Integer(10);
            Integer integer2 = new Integer(10);
            Integer integer3 = new Integer(127);
    
            Integer a1 = 127; //或者写成Integer a1 = Integer.valueOf(127);
            Integer a2 = 127;//或者写成Integer a2 = Integer.valueOf(127);
    
            Integer a = 128;
            Integer b = 128;
    
            System.out.println("int1 == int2 -> " + (int1 == int2));
            System.out.println("int1 == integer1 -> " + (int1 == integer1));
            System.out.println("integer1 == integer2 -> " + (integer1 == integer2));
            System.out.println("integer3 == a1 -> " + (integer3 == a1));
            System.out.println("a1 == a2 -> " + (a1 == a2));
            System.out.println("a == b -> " + (a == b));
        }
    }
    

    运行结果:
    在这里插入图片描述
    下面我们就来详细解释一下,为什么是上面的结果:

    1. 因为int1与int2比较的是数值,所以两者相等,这个很容易理解;
    2. 因为Integer是int的包装类,当Integer与int进行 == 比较时,Integer就会拆箱成一个int类型,所以还是相当于两个int类型进行比较,所以两者就是相等的;
    3. integer1和integer2这两个都是对象类型,此时使用==比较的不再是数值,而是两者是否为同一对象。因为两者的地址值不一样,所以两者不相等;
    4. integer3是一个对象类型,而a1是一个常量,它们在内存中存放的位置不一样,所以两者也不相等;
    5. 因为127在进行装箱时,会对-128到127之间的数进行缓存,当再创建a2时,发现缓存中已经存在127这个数了,就直接取出来赋值给a2,所以a1 == a2;
    6. 因为128超过了缓存范围,此时就是使用new Integer()来new一个对象了,所以a、b都是new Integer(128)出来的变量,所以两者不相等。

    3.5、自动装箱的弊端

    自动装箱有一个问题,那就是在一个循环中进行自动装箱操作的情况,如下面的例子就会创建多余的对象,影响程序的性能。

    Integer sum = 0;
     for(int i=1000; i<10000; i++){
       sum+=i; //因为Integer是包装类,当包装类与基本数据类型进行运算时,就会先拆箱,再装箱
    }
    

    上面的代码sum+=i可以看成sum = sum + i,但是+这个操作符不适用于Integer对象,因为sum首先会进行自动拆箱操作,然后进行数值相加操作,最后进行自动装箱操作转换成Integer对象。其内部变化如下:

    int result = sum.intValue() + i;
    Integer sum = new Integer(result);
    

    由于我们这里声明的sum为Integer类型,在上面的循环中会创建将近10000个无用的Integer对象,在这样庞大的循环中,会降低程序的性能并且加重了垃圾回收的工作量。因此在我们编程时,需要注意到这一点,正确地声明变量类型,避免因为自动装箱引起的性能问题。

    四、基本数据类型包装类与String类的相互转换

    4.1、基本数据类型包装类—>String类:调用String类的valueOf()方法

    int i=12;
    String s1=String.valueOf(i);
    System.out.println(s1); //12
    
    //参数为包装类
    Integer i1=new Integer(13);
    String s2=String.valueOf(i1);
    System.out.println(s2); // 13
    
    double d=12.3;
    String s3=String.valueOf(d);
    System.out.println(s3); // 12.3
    
    //总结:基本数据类型包装类——>String类:调用String类的valueOf()方法
    

    注意点:String类的valueOf()方法中的参数可以为基本数据类型,也可以为包装类。

    4.2、String类—>基本数据类型包装类:调用包装类的parseXxx()方法

    String s1="123";
    int i1=Integer.parseInt(s1);
    System.out.println(i1); // 123
    
    double d=Double.parseDouble(s1);
    System.out.println(d); // 123.0
    
    float f=Float.parseFloat(s1);
    System.out.println(f); // 123.0
    
    //总结:String类——>基本数据类型包装类:调用包装类的parseXxx()方法
    

    Java包装类与自动拆装箱也是Java中一个非常重要的知识点,无论是在日常开发还是面试和笔试中都经常用到。希望本篇文章能够对你有所帮助。

    展开全文
  • 包装类的使用

    2021-01-15 17:08:27
    1.java提供了8中基本数据类型对应的包装类,使得基本数据类型的变量具有类的特征。 2.掌握的:基本数据类型、包装类、String三者之间的相互转换 基本数据类型---->包装类:调用包装类的构造器 包装类---->基本...

    包装类的使用:

    1.java提供了8中基本数据类型对应的包装类,使得基本数据类型的变量具有类的特征。
    2.掌握的:基本数据类型、包装类、String三者之间的相互转换
    基本数据类型---->包装类:调用包装类的构造器
    包装类---->基本数据类型:调用包装类的xxxValue()
    JDK 5.0新特性:自动装箱与自动拆箱
    自动装箱:基本数据类型---->包装类

    int num = 10;
    Integer in1 = mum;
    
    bolean b = true;
    Boolean b1 = b;
    

    自动拆箱:包装类----->基本数据类型

    Integer num = new Integer(10);
    		int num3 = num;
    

    基本数据类型、包装类---->String类型:调用String重载的valueOf(Xxx xxx)
    方式一:连接运算
    方式二:调用String的valueOf(Xxx xxx)

    String类型----->数据基本类型、包装类:调用包装类的parseXxx(String s )
    可能会报NumberFormatException

    public void test1() {
    		Object o1 = true? new Integer(1) : new Double(2.0);
    		System.out.println(o1);
    	}
    

    结果为:1.0

    @Test
    	public void test2() {
    		Integer i = new Integer(1);
    		Integer j = new Integer(1);
    		System.out.println(i == j);//false
    		
    		Integer m = 1;
    		Integer n = 1;
    		System.out.println(m == n);//true
    		
    		Integer x = 128;//相当于new了一个Integer对象
    		Integer y = 128;
    		System.out.println(x == y);//false
    		
    	}
    

    Integer内部定义了IntegerCache结构,IntegerCache中定义了Integer[ ],
    保存了从-128~127范围的整数。如果我们使用自动装箱 的方式:给Integer赋值的范围在-128~127范围内时,可以直接使用数组中的元素,不用再去new了。
    目的:提高效率

    展开全文
  • 不是的实例,即不是的引用,这里并没有的存在。a 是指向一个 int 类型的引用,指向 7 这个字面值。由于其大小确定生存期可知(这些定义在某个程序块中,程序块退出后,字段值就消失),因此存在栈中. 由于栈的...
  • 一、基本数据类型对象包装类概述*a 基本类型包装类的产生: 在实际程序使用中,程序界面上用户输入的数据都是以字符串类型进行存储的,需要把字符串数据,根据需求转换成指定的基本数据类型,如年龄需要转换成int...
  • JAVA的包装类

    千次阅读 2018-01-13 15:56:34
    但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper ...
  • 行业分类-外包设计-包装开启特征结构及其制造方法.zip
  • 包装类

    2017-02-20 14:40:53
    一、了解包装类 在Java中一直提倡一个概念:一切皆对象,那么结合object的特点实际上就非常容易理解(在全部都是对象时,Object才可以达到统一参数的目的),但是在这之中就出现了一个不和谐的地方:基本数据类型...
  • java八种基本数据类型及包装类详解

    万次阅读 多人点赞 2018-12-20 10:14:40
    特征,所以实际使用中很不便所以为java八种基本数据类型提供了对应的包装类。 基本数据类型 对应包装类 包装类的父类 byte java.lang.Byte ...
  • Java包装类以及作用

    2020-02-05 18:11:48
    包装类就是讲8种基本数据类型进行包装,转化为类的形式,具有java面向对象的特征,基本数据类型没有类的属性,比如方法 2、包装类作用 包装类中,首先,可以调用大量方法,讲string类和int类等进行转换,其次在...
  • 【课程目标】:快速学习、应用Java内置包装类和常用类 【课程呈现形式】:PPT课件+讲解+编写代码演示 【课程特点】: 1)讲师经过精心的备课,以精简的语言,提炼了Java内置包装类和常用类(Number类、Math类、...
  • 为什么存在这两种类型呢? 在Java中,new的对象存储在堆里,通过栈中的引用来使用这些...Java是一个面向对象的编程语言,基本类型并不具有对象的性质,为了让基本类型也具有对象的特征,就出现了包装类型(如我们在使
  • Java面向对象 - 包装类

    2021-01-16 12:24:53
    在JAVA中,八大基础数据类型(int,float,double…)是不具备对象的特征的,比如基本数据类型就不能调用方法,功能简单,为了让基本数据类型也具备对象的特征,就有了JAVA包装类。 我们知道基础数据类型是没有属性的...
  • 包装类 一、在Java中,8中基本数据类型,并不符合面向对象的编程机制。他们不属于Object的类层次结构(8中基本数据类型没有父类)。也就是说8种基本数据类型,没有属性和方法。为了让基本数据类型也能像其他引用类型...
  • js的包装类

    千次阅读 2018-08-20 09:03:06
    实际上,每当读取一个基本类型值的时候,后台就会创建一个对应的基本包装类型的对象,从而能够调用一些方法来操作这些数据。 一.基本包装类型概述 var box = 'Mr. Lee';//定义一个字符串 ...
  • 这个问题的重心不仅仅在于考察对包装类存在合理性的认识,也在考察对基本数据类型存在意义的理解。 我们都知道在Java语言中,new一个对象存储在堆里,我们通过栈中的引用来使用这些对象。但是对于经常用到的一系列类...
  • 有时候我们需要把基本数据类型转换为对象类型。java中的包装器解决了这个需求。 什么是包装器呢?...对象包装是不可变的,不可以更改包装器中包装的值,这句话的意思可以理解为Integer本身(构.
  • java中数据类型有两 基本数据类型 引用类型 基本数据类型 整数型 byte - 8bit short - 16bit int - 32bit long - 64bit 【赋值时一般在数字后加上** L**(大小写都可以,建议大写与数字1或字母i大写区分开)】 ...
  • Java基本类型及其包装类1.java中的基本类型java中一共提供了8中基本数据类型,分别有byte,short,int,long,float,double,boolean,char; .除了这几种基本变量以外,其他的类型都是引用类型(数组,类,接口等). 基本数据的...
  • Java 包装类

    2020-01-27 10:24:28
    在JAVA中,八大基础数据类型(int,float,double…)是不具备对象的特征的,比如基本数据类型就不能调用方法,功能简单,为了让基本数据类型也具备对象的特征,就有了JAVA包装类。 基础数据类型是没有属性的,也是不...
  • 1.包装类的作用 Java是一种面向对象的编程语言,却存在几个不具有对象特征的异类;...通过包装类可以让基本数据类型获取对象一样的特征,行使对象相关的权益。 2.基本数据类型和包装类的对应 3. ...
  • Java中的8种基本数据类型及其包装类 1、8种基本数据类型基本知识 对于上图的注意事项: 1、java八种基本数据类型分为四类八种,四类分别为整型、浮点型、布尔型、字符型;八种分别为byte、short、int、long、float、...
  • 包装类: Java增强的包装类: Java是面向对象编程语言,但同样提供了8种基本数据类型,这8种基本数据类型不支持面向对象的编程机制,基本数据类型同样也不具备“对象”的特征:没有Field成员变量、没有方法可以被...
  • 基本数据类型和包装类的对象之间的拆装箱 基本类型、包装类与String类间的转换 包装类的使用 针对八种基本数据类型定义相应的引用类型—包装类(封装类) 有了类的特点,就可以调用类中的方法,Java才是真正...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 120,489
精华内容 48,195
关键字:

包装类的特点