精华内容
下载资源
问答
  • java包装类的概念常用方法详解
    2021-08-16 01:38:18

    java包装类的概念及常用方法详解

    包装类的概念

    ​ 通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变 量进行打包封装处理变成对象,而负责将这些变量声明为成员变量进行对象化处理的相关类,叫做包装 类。

     Person p = new Person(); // 对象
     int num = 10; // 非对象
    

    包装类的分类

    包装类对应的基本类型
    java.lang.Bytebyte
    java.lang.Shortshort
    java.lang.Integerint
    java.lang.Longlong
    java.lang.Floafloat
    java.lang.Doubledouble
    java.lang.Booleanboolean
    java.lang.Characterchar

    Integer类的概述

    1. 基本概念

      java.lang.Integer类内部包装了一个int类型的变量作为成员变量,主要用于实现对int类型的包装并 提供int类型到String类之间的转换等方法。

    2. 常用的常量

      常量类型和名称功能介绍
      public static final int MAX_VALUE表示int类型可以描述的最大值,即2^31-1
      public static final int MIN_VALUE表示int类型可以描述的最小值,即-2^31
      public static final int SIZE表示int类型采用二进制补码形式的位数
      public static final int BYTES表示int类型所占的字节个数
      public static final Class TYPE表示int类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Integer(int value)根据参数指定的整数来构造对象(已过时)
      Integer(String s)根据参数指定的字符串来构造对象 (已过时)
      int intValue()获取调用对象中的整数值并返回
      static Integer valueOf(int i)根据参数指定整数值得到Integer类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static int parseInt(String s)将字符串类型转换为int类型并返回
      static String toString(int i)获取参数指定整数的十进制字符串形式
      static String toBinaryString(int i)获取参数指定整数的二进制字符串形式
      static String toHexString(int i)获取参数指定整数的十六进制字符串形式
      static String toOctalString(int i)获取参数指定整数的八进制字符串形式
              System.out.println("将字符串转换为整数是" + i1);
              System.out.println("根据参数获取对应的十进制字符串是十进制" + Integer.toString(200));
              System.out.println("根据参数指定的整数获取对应的二进制数" + Integer.toBinaryString(200));
              System.out.println("根据参数指定的整数获取对应的十六进制数" + Integer.toHexString(200));
              System.out.println("根据参数指定的整数获取对应的八进制数" + Integer.toOctalString(200))
      

    装箱和拆箱的概念

    • 在Java5发布之前使用包装类对象进行运算时,需要较为繁琐的“拆箱”和“装箱”操作;即运算前先将 包装类对象拆分为基本类型数据,运算后再将结果封装成包装类对象。

    • 从Java5开始增加了自动拆箱和自动装箱的功能。

      Integer ia5 = 100; // 直接通过赋值运算符实现自动装箱功能
      int ib = ia5; // 直接通过赋值运算符实现自动拆箱功能
      

    自动装箱池

    • 在Integer类的内部提供了自动装箱池技术,将-128到127之间的整数已经装箱完毕,当程序中使用 该范围之间的整数时,无需装箱直接取用自动装箱池中的对象即可,从而提高效率。

      Integer t1 = 127;
              Integer t2 = 127;
              System.out.println(t1 == t2); // ture
              System.out.println(t1.equals(t2)); // true
              Integer t3 = new Integer(127);
              Integer t4 = new Integer(127);
              System.out.println(t3 == t4); // false
              System.out.println(t3.equals(t4)); // true
      

    Double类的概述

    1. 基本概念

      java.lang.Do uble类型内部包装了一个double类型的变量作为成员变量,主要用于实现对double 类型的包装并提供double类型到String类之间的转换等方法

    2. 常用的常量

      常量类型和名称功能介绍
      public static final int SIZE表示double类型的二进制位数
      public static final int BYTES表示double类型的字节个数
      public static final Class TYPE表示double类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Double(double value)根据参数指定的浮点数据来构造对象(已过时)
      Double(String s)根据参数指定的字符串来构造对象 (已过时)
      double doubleValue()获取调用对象中的浮点数据并返回
      static Double valueOf(double d)根据参数指定浮点数据得到Double类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static double parseDouble(String s)将字符串类型转换为double类型并返回
      boolean isNaN()判断调用对象的数值是否为非数字–> 0/0.0
    4. 扩展:

      java.lang.Number类是个抽象类,是上述类的父类来描述所有类共有的成员。

    Boolean类的概述

    1. 基本概念

      java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量,主要用于实现对 boolean类型的包装并提供boolean类型到String类之间的转换等方法。

    2. 常用的常量

      常量类型和名称功能介绍
      public static final Boolean FALSE对应基值为false的对象
      public static final Boolean TRUE对应基值为true的对象
      public static final Class TYPE表示boolean类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Boolean(boolean value)根据参数指定的布尔数值来构造对象(已过时)
      Boolean(String s)根据参数指定的字符串来构造对象 (已过时)
      boolean booleanValue()获取调用对象中的布尔数值并返回
      static Boolean valueOf(boolean b)根据参数指定布尔数值得到Boolean类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static boolean parseBoolean(String s)将字符串类型转换为boolean类型并返回
      ((s != null) && s.equalsIgnoreCase(“true”))

    Character类的概述

    1. 基本概念

      java.lang.Character类型内部包装了一个char类型的变量作为成员变量,主要用于实现对char类型 的包装并提供字符类别的判断和转换等方法。

    2. 常用的常量

      常量类型和名称功能介绍
      public static final int SIZE表示char类型的二进制位数
      public static final int BYTES表示char类型的字节个数
      public static final Class TYPE表示char类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Character(char value)根据参数指定的字符数据来构造对象(已过时)
      char charValue()获取调用对象中的字符数据并返回
      static Character valueOf(char c)根据参数指定字符数据得到Character类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static boolean isUpperCase(char ch)判断参数指定字符是否为大写字符
      static boolean isLowerCase(char ch)判断参数指定字符是否为小写字符
      static boolean isDigit(char ch)判断参数指定字符是否为数字字符
      static char toUpperCase(char ch)将参数指定的字符转换为大写字符
      static char toLowerCase(char ch)将参数指定的字符转换为小写字符

    包装类(Wrapper)的使用总结

    • 基本数据类型转换为对应包装类的方式

      调用包装类的构造方法或静态方法即可

    • 获取包装类对象中基本数据类型变量数值的方式

      调用包装类中的xxxValue方法即可

    • 字符串转换为基本数据类型的方式

      调用包装类中的parseXxx方法即可

    更多相关内容
  • 主要介绍了Java包装类,结合实例形式分析了Java包装类基本概念、功能、原理、用法及操作注意事项,需要的朋友可以参考下
  • Java包装类的应用场景介绍 ,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。今天讲一下 Java 包装类的的由来,自动装箱、拆箱的概念和原理。什么是包装类型Java 设计当初就提供了 8 种 基本数据...

    本篇文章给大家带来的内容是关于Java中的包装类是什么?Java包装类的应用场景介绍 ,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。

    今天讲一下 Java 包装类的的由来,及自动装箱、拆箱的概念和原理。

    什么是包装类型

    Java 设计当初就提供了 8 种 基本数据类型及对应的 8 种包装数据类型。我们知道 Java 是一种面向对象编程的高级语言,所以包装类型正是为了解决基本数据类型无法面向对象编程所提供的。

    下面是基本数据类型与对应的包装类型。基本数据类型包装类型byteByte

    booleanBoolean

    shortShort

    charCharacter

    intInteger

    longLong

    floatFloat

    doubleDouble

    下面是包装类型的继承结构图。

    ad5d11b54536db0290dd224e4780a44a.png

    从以上图表可以对基本类型和包装类型有一个全面的了解。

    包装类应用场景

    1、集合类泛型只能是包装类;// 编译报错

    List list1 = new ArrayList<>();

    // 正常

    List list2 = new ArrayList<>();

    2、成员变量不能有默认值;private int status;

    基本数据类型的成员变量都有默认值,如以上代码 status 默认值为 0,如果定义中 0 代表失败,那样就会有问题,这样只能使用包装类 Integer,它的默认值为 null,所以就不会有默认值影响。

    3、方法参数允许定义空值;private static void test1(int status){

    System.out.println(status);

    }

    看以上代码,方法参数定义的是基本数据类型 int,所以必须得传一个数字过来,不能传 null,很多场合我们希望是能传递 null 的,所以这种场合用包装类比较合适。

    还有更多应用场景就不一一例举了,欢迎留言共同探讨包装类的更多的应用场景。

    自动装箱、拆箱

    Java 5 增加了自动装箱、拆箱机制,提供基本数据类型和包装类型的相互转换操作。

    自动装箱

    自动装箱即自动将基本数据类型转换成包装类型,在 Java 5 之前,要将基本数据类型转换成包装类型只能这样做,看下面的代码。Integer i1 = new Integer(8);

    Integer i2 = Integer.valueOf(8);

    // 自动装箱

    Integer i3 = 8;

    以上 3 种都可以进行转换,但在 Java 5 之前第 3 种方法是编译失败的,第 3 种方法也正是现在的自动装箱功能。另外,第一种构造器方法也不推荐使用了,已经标为废弃了。

    其实自动装箱的原理就是调用包装类的 valueOf 方法,如第 2 个方法中的 Integer.valueOf 方法。

    自动拆箱

    自动拆箱即自动将包装类型转换成基本数据类型,与自动装箱相反,有装就有拆,很好理解。// 自动拆箱

    int i4 = i3;

    int i5 = i3.intValue();

    继续上面的例子,把 i3 赋值给 i4 就是实现的自动拆箱功能,自动装箱的原理就是调用包装类的 xxValue 方法,如 i5 中的 Integer 的 intValue 方法。

    自动装箱、拆箱不只是体现在以上的例子,在方法接收参数、对象设置参数时都能自动装箱拆箱。

    展开全文
  • 基本类型,或者叫做内置类型,是Java中不同于的特殊类型,是我们编程中使用最频繁的类型。Java是一种强类型语言,第一次声明变量必须说明数据类型,第一次变量赋值称为变量的初始化。

    1.Java基本类型及其包装类

    基本类型,或者叫做内置类型,是Java中不同于类的特殊类型,是我们编程中使用最频繁的类型。Java是一种强类型语言,第一次声明变量必须说明数据类型,第一次变量赋值称为变量的初始化。Java中共有8种基本类型,可分为三类:

    • 数值类型:byte,short,int,long,float,double
    • 布尔类型:boolean
    • 字符类型:char

    其中数值类型又可分为整数类型byte、short、int、long和浮点数类型float、double;

    除此之外其它的类型都可算为引用类型(如类、数组等);因为基本类型不具有自己的属性和方法,为了方便操作,Java提供了将基本类型封装后的包装类:

    基本类型包装类默认值字节数表示范围
    byteByte01byte-128~127
    shortShort02byte-32768~32767
    int0L或者0l4byte4byte-2147483648~2147483,47
    longLong08byte-2^63 ~ 2^63-1
    floatFloat0.0F或者0.0f4byte1.4E-45~3.4028235E38
    doubleDouble0.08byte4.9E-324~1.7976931348623157E308
    booleanBooleanfalse1bytetrue false
    charCharacter/u00002byte\u0000(即为0) ~ \uffff(即为65535)

    FloatDouble的最小值和最大值都是以科学记数法的形式输出的,结尾的"E+数字"表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140,3.14E-3就是3.14/1000=0.00314。

    对于基本类型的取值范围,我们不用强记,在它们对应的包装类中可以直接获取到,如:

    int maxValue = Integer.MAX_VALUE; //int最大值
    int minValue = Integer.MIN_VALUE; //int最小值
    

    2.数据类型之间的转换

    数据类型之间的转换分为两种情况:

    1)自动转换,比如当一个较“小”数据与一个较"大"的数据进行运算时,系统会自动把"小"数据转换成"大"数据,然后再进行运算;又或者在调用方法时,实际的参数比方法声明的参数"小"时,系统也会自动把"小"数据转换成"大"数据,然后再进行方法的调用,这里说的"大""小"指的是按取值范围区分的大小类型,数据类型由"小"到"大"排序:(byte、short、char)< int < long < float < double。

    byte b=1; 
    int i=b; //自动转换为int
    double d=b; //自动转换为double
    

    2)强制转换,将大类型转换为小类型时,可以使用强制转换,如:

    int num = (int)3.14; //double强转为int,可想而知,结果会丢失精度。
    

    3.装箱和拆箱

    在我们使用基本类型的包装类时,有时肯定需要在他们之间进行转换,例如:

    Integer i = Integer.valueOf(10); //将int转换为Integer
    int i2 = i.intValue(); //将Integer转换为int
    

    这种把基本数据类型转换成包装类的过程就叫装箱,而把包装类转换成基本数据类型的过程自然就称为拆箱了;从Java SE5开始,为了减少开发人员的工作,Java提供了自动拆箱与自动装箱功能,如果要生成一个数值为10的Integer对象,只需要这样就可以了:

    Integer i = 10; //系统自动调用Integer.valueOf()方法来进行装箱
    int n = i; //系统自动调用Integer.intValue()方法进行拆箱
    

    自动拆装箱大大节省了开发人员的精力,不用再关心什么时候需要拆箱和装箱。但是,在使用中还是有一些问题需要注意:

    1)包装类型数值的比较
    示例1:

    Integer i1 = 100;
    Integer i2 = 100;
    Integer i3 = 200;
    Integer i4 = 200;
    
    System.out.println(i1==i2); //true
    System.out.println(i3==i4); //false
    

    这里我们普遍会认为两次判断结果都是false,因为在比较对象时判断的是对象的引用,而不是判断对象的值;那么这里为什么i1i2为true呢,看以下源码我们就知道了:

    public static Integer valueOf(int i) {
        //从下面IntegerCache实现中可得知IntegerCache.high默认为127
            if(i >= -128 && i <= IntegerCache.high) 
       //也就是说当初始化赋值为-128~127时,会直接返回数组中对象的引用,不会创建新的对象
                return IntegerCache.cache[i + 128];
            else
                return new Integer(i);
        }
    
    private static class IntegerCache {
            static final int high;
            static final Integer cache[];
            static {
                final int low = -128;
                int h = 127;
                if (integerCacheHighPropValue != null) {
                    int i = Long.decode(integerCacheHighPropValue).intValue();
                    i = Math.max(i, 127);
                    h = Math.min(i, Integer.MAX_VALUE - -low);
                }
                high = h;
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
            }
            private IntegerCache() {}
        }
    

    从源码可以看出,在通过valueOf()方法创建Integer对象时,如果赋值在-128~127之间,就返回指向IntegerCache.cache中已经存在的对象的引用;否则创建一个新的Integer对象。

    上面i1和i2的数值为100,因此会直接从cache中取已经存在的对象,所以i1和i2指向的是同一个对象,而i3和i4则指向新创建的不同对象。

    示例2:

     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数值的比较,这里大家会条件反射的认为i1==i2应该输出true,但Double类的valueOf方法与Integer类的valueOf方法实现并不相同,因为在限定范围内整数的个数是有限的,而浮点数却不是。

    注意,Integer、Short、Byte、Character、Long这几个类的valueOf()方法的实现是类似的,都存在-128~127的缓存池。Double、Float的valueOf方法的实现是类似的,不存在缓存池。

    示例3:

    Boolean i1 = false;
    Boolean i2 = false;
    Boolean i3 = true;
    Boolean i4 = true;
    
    System.out.println(i1==i2); //true
    System.out.println(i3==i4); //true
    

    因为Boolean底层valueOf()方法返回值始终是两个常量TRUE和FALSE的引用,所以这里输出都是true:

    public static Boolean valueOf(boolean b) {
            return (b ? TRUE : FALSE);
        }
    
    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);
    

    2)包装类型运算及比较时的拆装箱

    Integer a = 1;
    Integer b = 2;
    Integer c = 3;
    Long d = 3L;
    Long e = 2L;
    
    System.out.println(c==(a+b));    //true
    System.out.println(c.equals(a+b));    //true
    System.out.println(d==(a+b));    //true
    System.out.println(d.equals(a+b));    //false
    System.out.println(d.equals(a+e));    //true
    

    这里需要注意的是,当 "=="运算符的两个操作数都是包装类型的引用,则比较指向的是否为同一个对象;而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。另外,对于包装类型,equals()方法不会进行类型转换。

    所以上面c==(a+b)中,a+b包含了算术运算,因此会触发自动拆箱过程,它们比较的是数值是否相等;

    而c.equals(a+b)会先触发自动拆箱过程,再触发自动装箱过程,也就是说a+b,会先各自调用intValue方法,得到了加法运算后的数值之后,便调用Integer.valueOf方法,再进行equals比较。

    同理对于后面的也是这样,不过要注意d.equals(a+b)和d.equals(a+e)输出的结果(如果数值是int类型的,装箱过程调用的是Integer.valueOf;如果是long类型的,装箱调用的Long.valueOf方法)。

    展开全文
  • java包装类及其转换

    2021-02-16 09:09:30
    java包装类包装类介绍包装类与基本数据类型、字符串之间的转换包装类与基本数据类型之间的转换基本数据类型转换成包装类包装类转换成基本数据类型自动装箱和自动拆箱包装类和基本数据类型同String类之间的转换基本...


    文章内容选自尚硅谷

    包装类介绍

    java当中的基本数据类型并不是类的一种,没有方法,也没有属性,而java是面向对象的编程,如果把基本数据类型也当作类的一种,再调用类的方法和属性,则java就能充分体现面向对象的编程思想。

    java为了解决这个问题,提供了包装类的工具。
    在这里插入图片描述
    图片选自尚硅谷

    如图所示,每一个包装类类型一一对应一种基本数据类型,其中除boolean和char的包装类,其余的父类皆为Number类。基本数据类型和包装类是两种独立的工具,两者可以相互转换。在编程中,可以使用包装类来代替基本数据类型,从而解决基本数据类型不能调用方法的问题。

    包装类与基本数据类型、字符串之间的转换

    可以用一张图来概括转换关系
    在这里插入图片描述
    图片选自尚硅谷

    包装类与基本数据类型之间的转换

    基本数据类型转换成包装类

    采用单元测试的方法,测试包装类与基本数据类型的转换
    格式为 包装类 变量名 = new 包装类(初始化值);
    代码如下,创建一个WrapperTest类

    package com.atguigu.java2;
    
    import org.junit.Test;
    
    public class WrapperTest {
      
    	@Test
    	public void test1(){
    		int num1 = 10;
    		Integer in1 = new Integer(num1);
    		System.out.println(in1 );
    		System.out.println(in1.toString() );
    		System.out.println(in1 + 1);
    		System.out.println(in1.toString()+1);
    	}
    }
    

    测试结果为

    10
    10
    11
    101

    分析这四个结果的原因,第一个是因为println方法,当参数列表为对象的引用的时候,会调用toString方法,由于包装类重写了toString方法,输出为10,详情可以参考java的Object类的方法(equals和toString).
    第二个是直接调用包装类的toString方法,其原理同第一个一样。
    第四个是测试toString返回的结果是整形还是字符串类型,可见返回了字符串类型
    第三个原则上来讲应该和第四个一样,但这出现了java的自动拆箱,表达式先转换为整型的结果,再进行输出。

    也可以在构造器中放入字符串

    		Integer in2 = new Integer("123");
    		System.out.println(in2.toString());
    		System.out.println(in2.toString()+1);
    

    结果为

    123
    1231

    但是,如果改为Integer in2 = new Integer(“123a”); 编译虽然会通过,但运行会报错java.lang.NumberFormatException

    特别地,针对布尔类型

    		Boolean b1 = new Boolean(true);
    		Boolean b2 = new Boolean("true");
    		System.out.println(b1);
    		System.out.println(b2);
    		Boolean b3 = new Boolean("true122");
    		Boolean b4 = new Boolean("truE");
    		System.out.println(b3);
    		System.out.println(b4);
    

    运行结果

    true
    true
    false
    true

    当字符串的值不为true,输出会报false而不是报错,而且字符串的值不区分大小写
    分析Boolean(“true122”)的构造器

        public Boolean(String s) {
            this(parseBoolean(s));
        }
    

    点击parseBoolean查看源码

        public static boolean parseBoolean(String s) {
            return ((s != null) && s.equalsIgnoreCase("true"));
        }
    

    可见,equalsIgnoreCase意思是不区分大小写,若不区分大小写的结果不为“true”,返回false。

    在WrapperTest的java文件中继续写一个类

    class Order{
    	boolean isMale;
    	Boolean isFemale;
    }
    

    再进行测试

    		Order order = new Order();
    		System.out.println(order.isMale);
    		System.out.println(order.isFemale);
    

    测试结果

    false
    null

    因为Boolean是一个类,isFemale是一个引用数据类型,引用数据类型的值要么为null,要么为地址值,因为这儿还没有创建对象,因此为null。

    包装类转换成基本数据类型

    方法:调用包装类的xxxValue()方法
    代码如下

    	@Test
    	public void test2(){
    		Integer in1 = new Integer(12);
    		int i1 = in1.intValue();
    		System.out.println(i1);
    	}
    

    测试结果为12

    自动装箱和自动拆箱

    自动装箱和自动拆箱是JDK5.0以后加入的新特性。
    自动装箱是把基本数据类型转换成包装类,运用场景

    	@Test
    	public void test3(){
    		int in1 = 13;
    		method(in1);
    		Integer num = 14;
    		Integer num2 = 15;
    		System.out.println(num.toString());
    		System.out.println(num2.toString());
    	}
    	
    	public void method(Object obj){
    		System.out.println(obj);
    	}
    

    结果为

    13
    14
    15

    在运行method方法的时候,方法的形参是类,按理说不能把基本数据类型放进去的,但是自动装箱会根据需求,把基本数据类型自动转换成包装类。

    自动拆箱就是把包装类转换成基本数据类型。

    		Integer num = 14;
    		int i1 = num;
    		System.out.println(i1);
    

    此为一个自动装、拆箱的过程,输出结果为14.

    包装类和基本数据类型同String类之间的转换

    有了自动装拆箱,包装类和基本数据类型可以看作一个整体,现在研究这个整体同String之间的转换。

    基本数据类型、包装类转换成String类型

    方法一: 通过连接运算的方法进行转换

    		int num1 = 20;
    		String str = num1+ "";
    

    方法二:调用String重载的valueOf(Xxx xxx)方法。

    	@Test
    	public void test4(){
    		Float f1 = 12.3f;
    		String str = String.valueOf(f1);
    		System.out.println(str);
    	}
    

    String类型转换成基本数据类型或包装类

    调用包装类中的parseXxx方法
    代码如下

    	@Test
    	public void test5(){
    		String str1 = "123";
    //		Integer in1 = (Integer)str1;
    		int i = Integer.parseInt(str1);
    		System.out.println(i);
    	}
    

    运行结果为123,可见String与包装类的转换,肯定要调用被转换类型的方法,即等号左边类内的方法。
    对于boolean型,如果把等号右边的字符串数据再加上其他字符,转换结果是false,如果不是布尔型,转换会报错。
    ps:注释的那一条语句,编译器是会报错的,因为强转类型的运用只能够发生在有子父类关系的时候。没有子父类关系,编译器会报错。
    在这里插入图片描述

    图片选自尚硅谷

    展开全文
  • 详解一、八种基本数据类型常识1.1、基本常识表对于上图有以下几点需要注意:java八种基本数据类型分为四类八种,四类分别为整型、浮点型、布尔型、字符型;八种分别为byte、short、int、long、float、double、...
  • 将原始类型和包装类分开以保持简单。当需要一个适合像面向对象编程的类型时就需要包装类。当希望数据类型变得简单时就使用原始类型。 原始类型不能为null,但包装类可以为null。包装类可用于实现多态性。
  • 包装类及常用方法简介2018年08月24日 19:40:08 徐念安 阅读数:555版权声明:Copyright 慕白博客 https://geekmubai.com https://blog.csdn.net/geekmubai/article/details/82024483包装类及常用方法简介JAVA 是一种...
  • 本关任务:使用 Byte 的定义与方法,完成 Byte 与基本数据类型的转换。 相关知识 Byte 将基本类型为 byte 的值包装在一个对象中。一个 Byte 的对象只包含一个类型为 byte 的字段。此外,该还为 byte 和 ...
  • java包装类

    2019-12-16 17:22:29
    目录 包装类的意义 包装类 每个基本数据类型都有对应的包装类 基本数据类型和包装之间的关系: ...1.one == two 【false】 ...2.2.java为了提高执行效率,在valuof()方法执行的过程中,提供了一个类似常量数组的...
  • Java 基础数据类型及其包装类Java 基础数据类型及其包装类基本数据类型Java 基本数据按类型可以分为四大类:布尔型1、整数型4、浮点型2、字符型1,这四大类包含 8 种基本数据类型。[外链图片转存失败,源站可能有防盗...
  • Java中的八种包装类

    2022-04-11 19:32:58
    Java提供的八种包装类装箱和拆箱整数型常量池Integer中的常用方法int 、Integer、String之间的相互转换 为什么需要包装类? 读以下程序: public class IntegerTest01 { public static void dosome(Object obj){ ...
  • Java中的包装类

    2021-03-22 16:58:40
    但在 Java 中不能定义基本类型对象,为了能将基本类型视为对象处理,并能连接相关方法Java 为每个基本类型都提供了包装类,如 int 型数值的包装类 Integer,boolean 型数值的包装类 Boolean 等。这样便可以把这些...
  • Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。1、整数:包括int,short,byte,long ,初始值为02、浮点型:float,double ,初始值为0.03、字符:char ,初始值为...
  • Java的数据类型分为两大: 基本数据类型 引用类型。 基本数据类型分为四大类型:布尔型、整数型、浮点型、字符型。 布尔型:boolean 整数型:byte,short,int,long 浮点型:float,double 字符型:char 引用...
  • 基本数据类型的包装类的作用是: 1.作为和基本数据类型对应的类类型存在,方便涉及到对象的操作。 2.包含每种基本数据类型的相关属性如最大值、最小值等,以及相关的操作方法。 基本类型 包装器类型...
  • 前言大家都知道在Java中,除了8种基本数据类型外,其他的都是引用类型。...所谓的包装类就是为8种基本数据类型分别定义了相应的引用类型,其对应关系如下:显然,除了intchar外,其余的包装类都是将对应...
  • 基本数据类型不是对象,不能调用方法,不能多态,例如,想要创建一个包含布尔,整数,浮点数的数组,基本数据类型是无法做到的,所以有了包装类,也符合java中一切皆对象的原则。 从基本数据类型到包装类除了int的...
  • 本文为包装类的学习笔记,刚开始学习Java,有错误不完善的地方还请大佬们指出,谢谢~ 1. 包装类概述 Java中将8种基本数据类型进行包装,形成了8种包装类。包括:整型(byte、short、int、long),浮点类型(float...
  • 1 包装类 我们前面学习的八种基本数据类型并不是对象,为了将基本类型数据和对象之间实现互相转化,JDK 为每一个基本数据类型提供了相应的包装类。 1.1 包装类基本知识 Java 是面向对象的语言,但并不是“纯面向对象...
  • 我们都知道在Java语言中,new一个对象存储在堆里,我们通过栈中的引用来使用这些对象;但是对于经常用到的一系列类型如int,如果我们用new将其存储在堆里就不是很有效——特别是简单的小的变量。所以就出现了基本...
  • Java中的String类、常用类及包装类
  • java包装类

    2019-08-21 07:43:57
    java包装类 Java中提供的类------官方API帮助文档 Application Programming Interface 应用程序编程接口,一些预先创建好的类及方法,目的是为了让我们更好进行程序开发 包装类 数学相关 日期相关 字符串相关 ...
  • java中的数据类型 包装类与基本数据类型 java中提供了8中基本类型:6中数字类型(4个整数型,2个浮点型),1种字符类型,还有1种布尔类型。 整数: int 、short、byte、long,...java包装类包括:Integer、Long...
  • java中的包装类

    2021-08-06 16:03:00
    1、包装类 相信各位小伙伴们对基本数据类型都非常熟悉,例如 int、float、double、boolean、char 等。基本数据类型是不具备对象的特性的,比如基本类型不能...将字符串和本类型及包装类互相转换的方法 Integer包方法
  • Java包装类及类型转换

    2018-12-05 14:36:37
    有时候一个函数需要传递一个Object变量 而你想传递int类型的进去显然不行,这就要用到包装类。 public void test(Object obj){ } 想传递5进去就可以这样 test(new Integer(5)); 2 集合不允许存放基本类型数据,只能...
  • 总述 数据,是一个程序最基本的要素,它的最终形式一定是基本...Java给每一个基本类型提供了包装类,放在java.lang包下。 所有对应基本类型,其包装类共有八个: Integer (int) Long (long) Short (short) Doubl...
  • Java中共有8种基本类型数据,同时每种基本类型又有对应的包装类。 基本数据类型(默认值) 包装类(默认值) 取值范围 byte (0) Byte (null) -128~127 short (0) Short(null) -32768~...
  • Java每个基本类型在java.lang包中都有一个相应的包装类 包装类有何作用 提供了一系列实用的方法 集合不允许存放基本数据类型数据,存放数字时,要用包装类型 这八种包装类所继承的父类不全都相同。 1)Integer,...
  • Java包装类型有几种

    千次阅读 2021-03-14 16:35:05
    【相关学习推荐:java基础教程】Java包装类型有8种,分别是:Java中的基本类型功能简单,不具备对象的特性,为了使基本类型具备对象的特性,所以出现了包装类,就可以像操作对象一样操作基本类型数据。一、基本类型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,255
精华内容 42,502
热门标签
关键字:

java包装类及其用法

java 订阅