8种包装类型

其他 2023-06-11 19:49:57 阅读次数: 0

包装类型

概述

因为8种基本数据类型不够用 , 所以java为8种基本数据类型又对应准备了8种包装类型。8种包装类属于引用数据类型，父类是Object

调用doSome()方法的时候需要传一个数字进去。但是数字属于基本数据类型，而doSome()方法参数的类型是Object。

  • 需要把基本数据类型的数字包装成对象传进去
  • 包装类型是引用数据类型 , 一定重写了 toString()方法 , 将其转换成字符串方便输出
public class IntegerTest01 {
    
    
    //入口
    public static void main(String[] args) {
    
    

        // 把100这个数字经过构造方法包装成对象传进去。
        MyInt myInt = new MyInt(100);
        doSome(myInt);
    }

    public static void doSome(Object obj){
    
    
        //包装类型是引用数据类型 , 一定重写了 toString 方法 , 方便输出
        System.out.println(obj);
    }
}

这种包装类目前是我自己写的。实际开发中我们不需要自己写。

public class MyInt {
    
    
    int value;

    public MyInt() {
    
    
    }

    public MyInt(int value) {
    
    
        this.value = value;
    }

    //重写 toString 方法 , 方便输出
    @Override
    public String toString() {
    
    
        return String.valueOf(value);
    }
}
基本数据类型名 包装数据类型名
byte java.lang.Byte（父类Number）
short java.lang.Short（父类Number）
int java.lang.Integer（父类Number）
long java.lang.Long（父类Number）
float java.lang.Float（父类Number）
double java.lang.Double（父类Number）
boolean java.lang.Boolean（父类Object）
char java.lang.Character（父类Object）

Number(数字对应的包装类的父类)

Number是一个抽象类，无法实例化对象。 Number类中负责拆箱的 xxxValue() 方法( 引用 -> 基本 )

  • 在java5之后，引入了一种新特性，自动装箱和自动拆箱 , 有了自动拆箱之后，Number类中的这些方法就用不到了
方法名 功能
byte byteValue() 以 byte 形式返回指定的数值
double doubleValue() 以 double 形式返回指定的数值
float floatValue() 以 float 形式返回指定的数值
int intValue() 以 int 形式返回指定的数值
long longValue() 以 long 形式返回指定的数值
shortValue() 以 short 形式返回指定的数值 
public class IntegerTest02 {
    
    
    public static void main(String[] args) {
    
    
        // 基本数据类型 -(Integer构造方法的包装)->引用数据类型（装箱）
        Integer i = new Integer(123);

        // 将引用数据类型--(Number类中负责拆箱的 xxxValue() 方法)-> 基本数据类型
        float f = i.floatValue();
        System.out.println(f); //123.0

        // 将引用数据类型--(转换为)-> 基本数据类型（拆箱）
        int retValue = i.intValue();
        System.out.println(retValue); //123
    }
}

Integer类的构造方法

其它的包装类型和Integer包装类型的构造方法原理相同 , 都是实现装箱的功能

  • 在java5之后，引入了一种新特性，自动装箱和自动拆箱 , 有了自动装箱之后，包装类这些构造方法就用不到了
  • 虽然有了自动装箱的功能 , 但本质还是调用的包装类构造方法创建的对象
方法名 功能
Integer Integer(int) 将int类型的数字包装成Integer类型 , Java9之后不建议使用该构造方法了 , Integer 类的静态方法 valueOf 可实现相同功能
Integer Integer(String) 将String类型的数字包装成Integer类型 , 字符串的内容不是一个数字不可以包装成Integer。运行时出现数字格式化异常：NumberFormatException 
public class IntegerTest03 {
    
    
    public static void main(String[] args) {
    
    

        // 将数字100转换成Integer包装类型（int --> Integer）
        Integer x = new Integer(100);
        System.out.println(x);

        // 将String类型的数字，转换成Integer包装类型（String --> Integer）
        Integer y = new Integer("123");
        System.out.println(y);
        
        // 字符串的内容不是一个“数字”不可以包装成Integer。运行时出现数字格式化异常：NumberFormatException
        //Integer a = new Integer("中文");


        //其它的包装类型和Integer包装类型的方法原理相同
        // double -->Double
        Double d = new Double(1.23);
        System.out.println(d);

        // String --> Double
        Double e = new Double("3.14");
        System.out.println(e);
    }
}

自动装箱/拆箱(方便编程)

在java5之后，引入了一种新特性，自动装箱和自动拆箱**(+ - * / == 等运算符会触发自动拆箱机制 )**

自动装箱：基本数据类型自动转换成包装类 (装箱可以理解为将低级包装成高级的过程)

  • 底层先使用的是 Integer 类的静态的 valueOf(int i)方法 , 根据数字的范围判断是从整数型常量池中拿 , 还是在堆中创建

自动拆箱：包装类自动转换成基本数据类型 (拆箱可以理解将高级拆分成低级的过程)

  • 底层使用的是 Number 类的静态的 intValue() 方法
public class IntegerTest05 {
    
    
    public static void main(String[] args) {
    
    

        // 基本数据类型 --(自动转换)--> 包装类型：自动装箱
        Integer x = 900;
        System.out.println(x);

        // 包装类型 --(自动转换)--> 基本数据类型：自动拆箱
        int y = x;
        System.out.println(y);
    }
}

基本数据类型 和 包装类型在做 + - * / == 等运算时包装类型会自动拆箱

//只有有基本数据类型，判断的是值是否相同
Integer i11=127;
int i12=127;
System.out.println(i11==i12); //true

Integer i13=128;
int i14=128;
System.out.println(i13==i14);//true

// z保存的是一个Integer对象的内存地址
Integer z = 1000; 

// + 两边要求是基本数据类型的数字，z是包装类不属于基本数据类型，这里会进行自动拆箱。在java5之前你这样写肯定编译器报错。
System.out.println(z + 1);

整数型常量池

java中为了提高程序的执行效率，将 [-128到127] 之间的256个包装对象提前创建好， 放到了一个方法区的“整数型常量池”当中了，目的是只要用这个区间的数据不需要再new了，直接从整数型常量池当中取出来**(复用率高)**。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5d2vQWil-1680778021411)(D:\笔记\java\每章课堂画图\03-常用类\004-Integer的内存结构.png)]

public class IntegerTest06 {
    
    
    public static void main(String[] args) {
    
    
        //直接手动两个Integer对象
        Integer i = new Integer(1);
		Integer j = new Integer(1);
		System.out.println(i == j); //false
        
        //底层使用的是 Integer 类的静态的 valueOf(int i)方法 , 会根据数字的范围判断是从整数型常量池中拿 , 还是在堆中创建
        Integer m = 1; //底层 Integer.valueOf(1);
		Integer n = 1;//底层 Integer.valueOf(1);
		System.out.println(m == n); //true
        
        Integer x = 128;//底层 Integer.valueOf(128);
		Integer y = 128;//底层 Integer.valueOf(128);
		System.out.println(x == y);//False
    }
}

valueOf源码

  • 如果 i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回 . 如果不在 -128~127,就直接 new Integer(i)
public static Integer valueOf(int i) {
    
    
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

包装类的测试

三元运算符是一个整体 , 运算时精度会提升到最高

public class WrapperExercise01 {
    
    
    public static void main(String[] args) {
    
    
        //三元运算符是一个整体 , 运算时精度会提升到最高
        Object obj1 = true? new Integer(1) : new Double(2.0);
        System.out.println(obj1);// 1.0

        //分别计算
        Object obj2;
        if(true)
            obj2 = new Integer(1);
        else
            obj2 = new Double(2.0);
        System.out.println(obj2);//1
    }
}

Integer类的常用的方法

方法名 功能
static int parseInt(String s) 传参String，返回int , 字符串的内容要求是个数字 。 网页上文本框中输入的100实际上是"100"字符串 , 后台数据库中要求存储100数字，此时java程序需要将"100"转换成100数字
static String toBinaryString(int i) 将十进制转换成二进制字符串
static String toHexString(int i) 将十进制转换成十六进制字符串。
static String toOctalString(int i) 将十进制转换成八进制字符串
static Integer valueOf(int i) 将int类型的数字转化为Integer类型 , 底层会对数字的范围进行判断
static Integer valueOf(String str) 将String类型的数字转化为Integer类型 , 字符串的内容不是一个数字不可以包装成Integer , 底层会对数字的范围判断 
public class IntegerTest07 {
    
    
    public static void main(String[] args) {
    
    
        Integer a = new Integer("123");

        // static int parseInt(String s)
        // 传参String，返回int类型
        int retValue = Integer.parseInt("123"); 
        System.out.println(retValue + 100);

        
        // NumberFormatException
        //int retValue = Integer.parseInt("中文"); 

        // 其他包装类型原理相同
        double retValue2 = Double.parseDouble("3.14");
        System.out.println(retValue2 + 1); //4.140000000000001（精度问题）

        float retValue3 = Float.parseFloat("1.0");
        System.out.println(retValue3 + 1); //2.0

        // static String toBinaryString(int i)
        // 将十进制转换成二进制字符串。
        String binaryString = Integer.toBinaryString(3);
        System.out.println(binaryString); //"11" 二进制字符串

        // static String toHexString(int i)
        // 将十进制转换成十六进制字符串。
        String hexString = Integer.toHexString(16);
        System.out.println(hexString); // "10"

   
        //static String toOctalString(int i)
        // 将十进制转换成八进制字符串。
        String octalString = Integer.toOctalString(8);
        System.out.println(octalString); // "10"


        //static Integer valueOf(int i)
        // 将int类型的数字转化为Integer类型
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

        // static Integer valueOf(String s)
        // 将String类型的数字转化为Integer类型
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);
    }
}

静态方法和静态属性

public class WrapperMethod {
    
    
    public static void main(String[] args) {
    
    
        System.out.println(Integer.MIN_VALUE); //返回int的最小值
        System.out.println(Integer.MAX_VALUE);//返回int最大值
        
        System.out.println("byte的最大值：" + Byte.MAX_VALUE);
        System.out.println("byte的最小值：" + Byte.MIN_VALUE);

        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('a'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断是不是大写
        System.out.println(Character.isLowerCase('a'));//判断是不是小写

        System.out.println(Character.isWhitespace('a'));//判断是不是空格
        System.out.println(Character.toUpperCase('a'));//转成大写
        System.out.println(Character.toLowerCase('A'));//转成小写

    }
}

String int Integer之间互相转换

转换图

Integer --> String : 直接拼接空字符串 , 调用 Integer 类重写后的 toString 方法 , 调用 String 类静态的的 valueOf方法

String --> Integer: 直接调用 Integer 类的构造方法 , 调用 Integer 类静态的的 valueOf方法

int --> String : 直接拼接空字符串

String --> int: 调用 Integer 类静态的的 parseInt 方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vbAMthfR-1680778021412)(D:\笔记\java\每章课堂画图\03-常用类\005-String Integer int三种类型的互相转换.png)]

public class IntegerTest08 {
    
    
    public static void main(String[] args) {
    
    

        // String --> int
        int i = Integer.parseInt("100"); // i1是100数字
        System.out.println(i + 1); // 101

        // int --> String
        String s2 = i + ""; // "100"字符串
        System.out.println(s2 + 1); // "1001"
        
        // int --> Integer , 自动装箱
        Integer x = 1000;

        // Integer --> int , 自动拆箱
        int y = x;

        // String --> Integer
        Integer k = Integer.valueOf("123");

        // Integer --> String
        String str1 = k + "";
        String str2 = String.valueOf(k);
        String str3 = k.toString();

    }
}

猜你喜欢

转载自blog.csdn.net/qq_57005976/article/details/129996480
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022