• Javase | 包装类

    目录：

    1.包装类

    1.1 包装类

    • Java中为8种 基本数据类型又对应准备了8种包装类型。
    • 包装类属于 引用数据类型。
    • 包装类中有六个都是数字对应的包装类，他们父类都是 Number。

    1.2 包装类的分类

    1. byte类型对应的包装类：Byte (父类是Number)

    2. short类型对应的包装类：Short (父类是Number)

    3. int类型对应的包装类：Integer (父类是Number)

    4. long类型对应的包装类：Long (父类是Number)

    5. float类型对应的包装类：Float (父类是Number)

    6. double类型对应的包装类：Double (父类是Number)

    7. boolean类型对应的包装类：Boolean (父类是Number)

    8. char类型对应的包装类：Character (父类是Number)

    （包装类为引用数据类型）

    2.思考：为什么要提供8种包装类型？

    • 因为8种基本数据类型不够用，所以要提供了8种包装类型 (为引用数据类型)，满足不同的开发需求。

    • 现有以下需求：（使用包装类能满足以下开发需求）
      方法中的参数类型为Object o (引用数据类型) ，但传入的参数的类型为100(基本数据类型)，怎么解决这个问题呢？
      解： 将100封装为“包装类”即可符合参数传入要求，也一样能传入数据。

    • 例子如：

      public class IntegetTest01 {
    public static void main(String[] args) {
        /*
         现有以下需求:
         调用doSome()方法时传入一个数字100(基本数据类型),但doSome()方法要求传入的参数类			 型为: Object obj(引用数据类型),
         怎么解决这个问题？

         解: 可以将数字100经过构造“构造方法”包装成“对象”,把这个"对象"作为参数传入到		     doSome()方法中
         */

        //把数字100经过“构造方法”包装成“对象”
        MyInt myInt = new MyInt(100);
        //将“包装类对象”作为参数来传入到doSome()方法中
        doSome(myInt);

    }

public static void doSome(Object obj) { //方法参数为: 一个Object对象
    
          /*
          当没重写toString()方法时,底层默认使用的Object类的toString()方法 : 输出对象		      的“内存地址”信息，返回值为String类型
          如:
           System.out.println(obj); //com.ximo.nine_11.MyInt@7ef20235

           建议重写toString()方法
         */

        //输出重写了toString()方法的对象 : 输出对象中的数据
        System.out.println(obj);  // 100
    }
}


 class MyInt {  //自定义的包装类
    int value;
    public MyInt() {  //无参构造方法

    }
    public MyInt(int value) { //有参构造方法
        this.value = value;
    }

     /**
      * Object.toString()方法是Object类下有的方法，Object类是所有对象的父类，
      * 意味着其的子类也能调用toString()方法:
      *
      * Object.toString()方法 : 输出该对象的”内存地址“信息,返回值为String字符串类型 :
      * return getClass().getName() + "@" + Integer.toHexString(hashCode());
      *
      * Object.toString()方法的作用:
      * 1.将“对象”转换为“字符串”
      * 2.返回一个对象的“内存地址”信息，返回值为String类型。
      */
     //重写toString()方法
     @Override
     public String toString() {
         //返回对象中的数据,返回值类型为String类型
         return String.valueOf(value);
     }
 }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60

    3.通过访问包装类的常量，获取“最大值”和最小值

    • 通过访问包装类的常量，获取基本数据类型的“最大值”和最小值

         //通过访问“包装类的常量”，获取基本数据类型的“最大值”和“最小值”
   System.out.println("byte的最小值: "+Byte.MIN_VALUE); //-128
   System.out.println("byte的最大值: "+Byte.MAX_VALUE); //127
   System.out.println("short的最小值: "+Short.MIN_VALUE); //32768
   System.out.println("short的最大值: "+Short.MAX_VALUE); //32767
   System.out.println("int的最小值: "+Integer.MIN_VALUE); //-2147483648
   System.out.println("int的最大值: "+Integer.MAX_VALUE); //2147483647
   //-9223372036854775808
   System.out.println("long的最小值: "+Long.MIN_VALUE);
   //9223372036854775807
   System.out.println("long的最大值: "+Long.MAX_VALUE);
   System.out.println("float的最小值: "+Float.MIN_VALUE); //1.4E-45
   System.out.println("float的最大值: "+Float.MAX_VALUE); //3.4028235E38
   System.out.println("double的最小值: "+Double.MIN_VALUE); //4.9E-324
   //1.7976931348623157E308
   System.out.println("double的最大值: "+Double.MAX_VALUE);
   System.out.println(Boolean.FALSE); //false
   System.out.println(Boolean.TRUE); //true
   System.out.println(Character.MIN_VALUE);
   System.out.println(Character.MAX_VALUE);

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20

    4.装箱 和 拆箱：

    4.1 装箱

    • 装箱: 将“基本数据类型”类型转换为“引用数据类型”。

    • 装箱：创建包装类，将对应的“基本数据类型”数据存储到“包装类”中。

      例子如：

              /**
          将“基本数据类型”类型转换为 “引用数据类型” (装箱)
          装箱: 创建包装类,将对应的“基本数据类型”数据存储到“包装类”中。
         */
        //基本数据类型
        byte b =12;
        short s =12;
        int i =123;
        long l = 123L;
        float f = 123.0f;
        double d =123.0;
        boolean bl = true;
        char c = '中';

    //将“基本数据类型”转换为 “引用数据类型” : 装箱
    //将数字100转换为Byte包装类型 
    Byte B = new Byte(b);             //创建 “byte类型” 对应的包装类:    Byte
    Short S = new Short(s);           //创建 “short类型” 对应的包装类:   Short
	Integer I = new Integer(i);       //创建 “int类型” 对应的包装类:     Integer
    Long L = new Long(l);             //创建 “long类型” 对应的包装类:    Long
    Float F = new Float(f);           //创建 “float类型” 对应的包装类:   Float
    Double D = new Double(d);         //创建 “double类型” 对应的包装类:  Double
    Boolean BL = new Boolean(bl);     //创建 “boolean类型” 对应的包装类: Boolean
    Character C = new Character(c);   //创建 “char类型” 对应的包装类:    Character

        //输出包装类(引用数据类型)对象
        //包装类中重写了toString()方法,所以此处输出包装类中存储的"基本数据类型"数据
        System.out.println(B.toString()); //12
        System.out.println(S.toString()); //12
        System.out.println(I.toString()); //123
        System.out.println(L.toString()); //123
        System.out.println(F.toString()); //123.0
        System.out.println(D.toString()); //123.0
        System.out.println(BL.toString()); //true
        System.out.println(C.toString());  //中

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35

    4.2 拆箱

    • 拆箱: 将“引用数据类型”类型转换为“基本数据类型”。

    • 拆箱：调用各自包装类中有的xxxValue()方法，输出存储在包装类中的基本数据类型的数据。

      例子如：

        //基本数据类型
        byte b =12;
        short s =12;
        int i =123;
        long l = 123L;
        float f = 123.0f;
        double d =123.0;
        boolean bl = true;
        char c = '中';

        //装箱
        Byte B = new Byte(b);
        Short S = new Short(s);
        Integer I = new Integer(i);
        Long L = new Long(l);
        Float F = new Float(f);
        Double D = new Double(d);
        Boolean BL = new Boolean(bl);
        Character C = new Character(c);

        //拆箱
        /*
          拆箱 : 将"引用数据类型"转换为"基本数据类型"。
          调用各自包装类中有的xxxValue()方法，输出存储在包装类中的基本数据类型的数据。
         */
        byte b_Unpack = B.byteValue();
        Short S_Unpack = S.shortValue();
        Integer I_Unpack = I.intValue();
        Long L_Unpack = L.longValue();
        Float F_Unpack = F.floatValue();
        Double D_Unpack = D.doubleValue();
        Boolean BL_Unpack = BL.booleanValue();
        Character C_Unpack = C.charValue();

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33

    5.Number类：

    5.1 Number类的构造方法

    public Number()

    5.2 Number类中的方法

    • byte byteValue( )：
      以 byte 形式返回指定的数值。

    • double doubleValue( ) ：
      以 double 形式返回指定的数值。

    • float floatValue( ) ：
      以 float 形式返回指定的数值。

    • int intValue( ) ：
      以 int 形式返回指定的数值。

    • long longValue( )：
      以 long 形式返回指定的数值。

    • short shortValue( ) ：

    以 short 形式返回指定的数值。

    6.Integer类

    6.1 Integer类构造方法

    • Integer类的两大构造方法:

      Integer( int value )

      Integer( String s )

    • 例子如：

         //Integer的构造方法
   //将数字转换为Integer包装类型(int ---> Integer)
   Integer x = new Integer(100);
   System.out.println(x); //100

   //将String类型的数字，转换成Integer包装类型(String ---> Integer)
   Integer y = new Integer("123");
   System.out.println(y); //123

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

    • 不是一个数字，不能包装成Integer类，运行时会出现异常。

      //以下代码不会报错，是Integer类的构造方法的正确使用范畴
  Integer x = new Integer ("1000");
  Integer y = new Integer (1000);
     System.out.println(x);
  System.out.println(y);

  //这段代码会报错
  //不是一个数字，不能包装成Integer类，运行时会出现异常。
  Integer z = new Integer ("中国");
  System.out.println(z);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    6.2 Integer类常用方法

    int intValue( )

    • int intValue( ) : 以 int 类型返回该 Integer 的值。（拆箱要用到该方法）。

         //装箱
   Integer I = new Integer(123);

   //intValue() : 将Integer类型数据以int类型返回
   int i = I.intValue(); //String转换为int
   System.out.println(i); //123

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
    int parseInt( String s )

    • int parseInt(String s)：静态方法，传入String类型参数，返回值为int类型。

         //静态方法，传入String类型参数，返回值为int类型
   /*
    网页上文本框中输入的实际上是"100"字符串，后台数据库中要求存的是100数字，
    此时java程序要将“100”转换为数字100
    */
   int i  = Integer.parseInt("123");  //将“String类型”数据转换为“int类型”数据
   System.out.println(i);

   //该方法不能将中文装换为数字，否则会报“数字格式化异常”
 int i2  = Integer.parseInt("中国"); //报错: NumberFormatException(数字格式化异常)

   //照葫芦画瓢 --- 其他的包装类也有类似的方法
   //parseDouble、parseFloat ...

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
    String toBinaryString( int i )

    • String toBinaryString( int i) ： 为静态方法，

    • 将十进制转换为二进制，返回值为String类型。

         //静态的：将十进制转换为二进制，返回值为String类型
   String binaryString = Integer.toBinaryString(3);
   System.out.println(binaryString); // 11

      • 1
      • 2
      • 3
    String toHexString( int i )

    • String toHexString( int i) ： 为静态方法，

    • 将十进制转换为十六进制，返回值为String类型。

         //静态的：将十进制转换为十六进制，返回值为String类型
   String hexString1 = Integer.toHexString(16);
   String hexString2 = Integer.toHexString(17);
   System.out.println(hexString1); //10
   System.out.println(hexString2); //11

      • 1
      • 2
      • 3
      • 4
      • 5
    String toOctalString( int i )
    • String toOctalString( int i ) ： 为静态方法，
    • 将十进制转换为八进制，返回值为String类型。
       //静态的：将十进制转换为八进制，返回值为String类型
   String octalString = Integer.toOctalString(8);
   System.out.println(octalString); //10

    • 1
    • 2
    • 3
    Integer valueOf( int i )

    • Integer valueOf(int i) : 为静态方法，

    • 将int类型转换为Integer类型

      //静态的：将int类型转换为Integer类型
Integer i1 = Integer.valueOf(100);System.out.println(i1); //100

      • 1
      • 2
    Integer valueOf( String s )

    • Integer valueOf( String s ) : 为静态方法，

    • 将int类型转换为Integer类型

         //静态的：将String类型转换为Integer类型
   Integer i2 = Integer.valueOf("100");
   System.out.println(i2); //100

      • 1
      • 2
      • 3

    7.Double类的构造方法

    7.1 Double类的构造方法

    • Integer类的两大构造方法:

      Double( double value)

      Double(String s)

    • 例子如：

         //Double的构造方法
   //将数字转换为Double包装类型 (double ---> Double)
   Double x = new Double(1.23);
   System.out.println(x); //1.23

   //将String类型的数字，转换成Double包装类型 (String ---> Integer)
   Double y = new Double("3.14");
   System.out.println(y); //3.14

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

    8.自动装箱 和 自动拆箱：

    8.1 自动装箱

    • 在JDK1.5之后，支持“自动装箱”。

    • 自动装箱：将基本数据类型数据自动转换为包装类类型 (引用数据类型)。

         //自动装箱
   //100基本数据类型
   //int类型数据 - 自动转换为 -> Integer(包装类)
   Integer x = 100; //等于同于: Integer x =new Integer(100);

      • 1
      • 2
      • 3
      • 4

    8.2 自动拆箱

    • 在JDK1.5之后，支持“自动拆箱”。

    • 自动拆箱：将包装类类型 (引用数据类型) 自动转换为基本数据类型数据。

    • 当进行算术运算符、赋值运算符等操作时 ，会“自动拆箱”。

    • 例子如：

        	    //自动装箱
       Integer x = 1000;
       Integer y = 1000;

       Object obj = new Object();
       int a;

       /**
         当进行“算术运算符、赋值运算符等”操作时，会”自动拆箱“

         算术运算符 : + - * / % ++ - -
         赋值运算符等 : = += -= *= /= %=
        */
       //自动拆箱
       System.out.println(x + 1); 
       System.out.println(x - 1);
       System.out.println(x * 1);
       System.out.println(x / 1);
       System.out.println(x % 1);
       System.out.println(x++);
       System.out.println(x--);

       System.out.println(a=x);
       System.out.println(a+=x);
       System.out.println(a-=x);
       System.out.println(a*=x);
       System.out.println(a/=x);
       System.out.println(a%=x);

//会报错,因为“引用数据类型”无法赋值给“基本数据类型” (上面就不会报错，因为会“自动拆箱”)
       System.out.println(a=obj);

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31

    • 当进行 “= =运算符” 等操作时 ，不会“自动拆箱”。（==运算符不会触发自动拆箱机制）

      例子如：

                //自动装箱
         Integer x = 128;
         Integer y = 128;

         //进行 ==运算符 操作时，不会自动拆箱
        /*
          当比较基本数据类型时，==比较的是“值”。
          当比较引用数据类型时，==比较的是“内存地址”。
         */
        //两个Integer对象都需要new，内存地址自然是不一样的
        System.out.println(x==y); //false

        /**
         *
         * Java中为了提高程序的执行效率,将[-127到128]之间的所有“包装类对象”提前创建好，
         * 放到了一个“方法区”的“整数型常量池”中了，目的是只要用这个区间的数字不需要再去new
         * 对象了，直接从“整数型常量池中”取出来。
         *
         * x变量中保存的对象的内存地址和y变量中的保存的对象的内存地址是一样的。
         * 所以 x==y 为true
         */
        Integer a =127;
        Integer b =127;
        System.out.println(a==b);//true (两个引用都指向同一个对象，内存地址相同)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24

    • 有了“自动拆箱”之后，Number中的方法(拆箱方法)就用不上了，因为不再需要手动拆箱。

    9.String int Integer 类型互换

    在这里插入图片描述

           String s1 = "100";

        // String 转换为 int
        int i1 = Integer.parseInt(s1); //100
        System.out.println(i1 + 1); // 101

        // int 转换为 String
        String s2 = i1 + ""; //"101"字符串
        System.out.println(s2 + 1); //字符串拼接: "1011"

        // int 转换为 Integer
        //自动装箱
        Integer x = 1000;

        // Integer 转换为 int
        //自动拆箱
        int y = x;

        // String 转换为 Integer
        Integer k = Integer.valueOf("123");

        // Integer 转换为 String
        String e = String.valueOf(k);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
  • 相关阅读:
    扩大减产,NAND Flash市场迎来涨价潮 | 百能云芯
    随手笔记（四十）——maven打包后本地jar无法被项目引入
    lower_bound（）以及upper_bound()
    LaTeX各种数学符号
    记一次【RabbitMQ集群网络分区】的问题，以及网络分区时的影响范围和如何恢复
    java毕业设计宠物互助领售平台mybatis+源码+调试部署+系统+数据库+lw
    杂谈 跟编程无关的事情22
    【科研新手指南4】ChatGPT的prompt技巧 心得
    SpringBoot结合Vue.js+axios框架实现增删改查功能+网页端实时显示数据库数据（包括删除多条数据）
    一张图弄懂海外模型的有效特征
  • 原文地址：https://blog.csdn.net/m0_70720417/article/details/132842595