Java入门第十二节(二) 包装类

吴琼老师

已于 2022-11-15 10:32:39 修改

阅读量296

点赞数

分类专栏： Java入门基础阶段文章标签： java 开发语言缓存

于 2022-05-23 10:54:08 首次发布

本文链接：https://blog.csdn.net/u013280750/article/details/124888300

版权

Java入门基础阶段专栏收录该内容

30 篇文章 3 订阅

订阅专栏

文章目录

包装类

包装类

1. 啥是包装类？

基本数据类型没有任何方法，只是一个记录值，一个变量。
java是一种面向对象的编程语言，但是基本数据类型却不是面向对象的。数据类型之间又要经常发生转换，
- 如：String 类与基本数据类型。怎么解决这样的问题！？
- 这时候就需要功能更加完善的类，来替代基础类型。所以设计了更为贴近基本数据类型的代表类，叫做 包装类。

2. 对应关系

2.1. 基本类型与包装类型对应关系

包装类主要的作用就是，
- 当做参数传递。
- 方便与对象的操作。
使用 集合类型Collection 时使用包装类型而非基本类型 （后面在讨论~）。

基本类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

说明： int 和 char 类型不一样外，其余都是首字母大写对应。

2.2. 包装类的继承结构

基本数据类型分为三大类：数值型、字符型、布尔型； 但是他们的包装类的继承的父类不同；
所有的数值型都是继承 Number类 的；字符类型和布尔类型的直接父类是 Object类
- 通过查看类的继承结构。

3. 继承介绍

3.1. Number 类

数值类型 的父类，是一个抽象类 public abstract class Number extends Object。
- 例如： 在包装类Integer上 Ctrl+T也可以直接查看。

在这里插入图片描述

number常用方法

3.2. Integer类

由于数值型的父类都是Number，并且设计包装类的时候，它们的使用方法几乎一样，所以我们测试一个比较典型的基础类型的包装类。
只要会使用这一个包装类，其他数值类型的包装类几乎一致。

3.2.1 创建对象2种方式

想要使用包装类的方法，就需要将普通类型转换为包装类。
得到一个包装类，才能使用包装类中的方法，和父类方法。

创建对象的方式：

第一种：Integer i = new Integer(18); // 通过 new 对象的方式创建。
第二种：Integer.valueOf(18); 通过包装类，调用静态方法。

	 public static void main(String[] args) {
	 
	        //1.第一种创建方式，通过new关键字 创建对象，得到包装类。
	        Integer integer = new Integer(18);
	
	        //2.种通过包装类调用 静态方法，得到一个包装类。
	        Integer integer1 = Integer.valueOf(18);
	    }

3.2.2 String类与Int类型相互转换

转换只有数值型。
- String s ="你好中国";就不可以。
静态方法，可以类名直接调用parseInt(String s);，将字符串转换为 int 类型。
- 其他包装类，也有相同的方法！

	public static void main(String[] args) {
	
	        //1.从String 转为 int
	        String s="123";
	        //获取包装类,使用包装类中的方法
	        int i = Integer.parseInt(s);
	        System.out.println(i);
	
	
	        //2.将Int 类型 转换为String类型。
	        int i_1 = 127;
	        String s_1 = String.valueOf(i_1); //通过String类方法
	        System.out.println(s_1);
	
	
	    }

3.2.3 Integer 缓冲区

为什么包装类会有缓冲区，也是为了提高效率，Integer.valueOf(18);

用包装类包装数值时会创建大量对象，如果没有缓存的话，会有大量的包装类被创建，占用内存，降低效率。会先在初始化时缓存 -127~128的数字。

如果超过了该范围，则创建数值。

	public static void main(String[] args) {

        //1. 通过创建对象方式。
        Integer i = new Integer(18);
        Integer i_1 = new Integer(18);
        System.out.println(i==i_1);//false

        //2. 通过包装类的方式。
        Integer i_2 = Integer.valueOf(18);
        Integer i_3 = Integer.valueOf(18);
        System.out.println(i_2==i_3);//true;

        //3. 如果超过缓存设置
        Integer i_4 = Integer.valueOf(189);
        Integer i_5 = Integer.valueOf(189);
        System.out.println(i_4==i_5);// false 相当于重新创建。
    }

3.2.4 Integer 方法测试

包装类中方法的测试。
- 提示： 包装类比较数值是否相同，使用equals();不建议使用==。为什么？

public class Demo_Api2 {
    static Integer integer;
    public static void main(String[] args) {
        System.out.println(integer);//包装类，字面值也是null

        /*1.比较对象，int类型比较大小，
          2.Integer类型比较对象大小。
             规则：   a>b 1 ;a<b -1; a=b 0
         */

        //1.compare(a,b) 比较两个int数的值
        int compare = Integer.compare(8, 8);
        System.out.println(compare);

        //2. Integer 包装类型比较对象
        Integer i = new Integer(12);
        Integer i2 = new Integer(12);
        int i1 = i.compareTo(i2);
        System.out.println(i1);

        //数值类型的包装类比较值是否相等使用 equals。
        System.out.println(i==i2);//false
        System.out.println(i.equals(i2));//true


        System.out.println("--------------------------------");

        /* 数值类型转换
         */
        //3. Integer 转为 double
        double i_double = i.doubleValue();
        System.out.println(i_double);

        float i_float = i.floatValue();
        System.out.println(i_float);


        //将Intger类型转为int类型
        int i_int = i.intValue();
        System.out.println(i_int);

        System.out.println("------------------------------");
        //max min int类型最大值最小值
        int max = Integer.max(10, 8);
        System.out.println(max);
        int min = Integer.min(10, 7);
        System.out.println(min);

        /*转换进制
         */
        //转换为16进制
        String s = Integer.toHexString(100);
        System.out.println(s);
        //转换为8进制
        String s1 = Integer.toOctalString(100);
        System.out.println(s1);
        //转为2进制
        String s2 = Integer.toBinaryString(100);
        System.out.println(s2);
    }
}

3.3. 测试： Double包装类

与Integer包装类几乎一样。但是，Double类（Float），（都）不缓存。
- 有图有证据：调用 valueOf()的方法是创建对象。
包装类Double方法测试；

public class WrapperClass2 {
    Double d;
    public static void main(String[] args) {

        //1. 创建对象2种方式
        Double d1 = new Double("3.14d");//同3.14

        Double d2 = Double.valueOf(3.14d);
        Double d3 = Double.valueOf(3.14d);

        System.out.println(d1==d2);
        System.out.println(d2==d3);

        //2.默认值 null
        System.out.println(new WrapperClass2().d); //null 。

        // 3.parseDouble() 将String类型转换为 Double类型
        double d4 = Double.parseDouble("123d");
        System.out.println(d4);
        System.out.println(d4+2.20);

        //3.1 compare(double a,double b) 比较两个值大小 。相等 0 ，a>b 1; 反之-1
        int compare = Double.compare(d4, d2);
        System.out.println(compare); //1

        //3.1 intValue()

        int i = d1.intValue();
        System.out.println(i); //转换成int值，这样会缺失精度。

        //3.2 比较大小
        System.out.println(Double.max(d1,d4)); //返回最大值。
        System.out.println(Double.min(d1,d4)); //返回最小值。

    }
}

输出结果：

false
false
null
123.0
125.2
1
3
123.0
3.14

3.4. 字符串和包装类之间转换

String 类和 包装类 之间转换是经常用的。一般是数值型。
- 将包装类转为基本类型使用：包装类.parse包装类();

public class WrapperClass3 {
    public static void main(String[] args) {
        /*  1.从String类型“数字” 转换成 基本类型。
             1.1 调用各个包装类的静态方法 public static parse包装类();
         */
        String numberStr = "-128";
        byte b = Byte.parseByte(numberStr); //范围 -128~127 之间
        short s = Short.parseShort(numberStr);
        int i = Integer.parseInt(numberStr);
        long l = Long.parseLong(numberStr);
        float f = Float.parseFloat(numberStr);
        double d = Double.parseDouble(numberStr);

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);

        System.out.println("---------华丽的分割线---------");
        /*2.将包装类转换相应字符串形式
            2.1 需要调用String类中的 public static String valueOf(Object obj)
         */

        String sb = String.valueOf(b);
        String ss = String.valueOf(s);
        String si = String.valueOf(i);
        String sl = String.valueOf(l);
        String sf = String.valueOf(f);
        String sd = String.valueOf(d);

        System.out.println(sb);
        System.out.println(ss);
        System.out.println(si);
        System.out.println(sl);
        System.out.println(sf);
        System.out.println(sd+10);// 测试返回的字符串！ 拼接

    }
}

输出结果：

-128
-128
-128
-128
-128.0
-128.0
---------华丽的分割线---------
-128
-128
-128
-128
-128.0
-128.010

4. 自动拆箱和自动装箱

4.1 概述

拆箱和装箱，Jvm都是根据语法是否决定拆箱和装箱。 那什么是装箱？什么又是拆箱呢？
其实用白话来解释，就是包装类型和基本类型自动转换。
- 装箱：就是 把基本类型对应的引用类型的包装起来，即：基本向上转包装，形成包装类的过程。
- 拆箱：就是将引用类型的包装类转换成基本类型的过程。即：包装向下转基本 形成基本类型的过程。

4.2 拆箱和装箱使用

jvm会根据语法决定是装箱还是拆箱。
- 底层自动调用相应方法。

	public class Integer_API {
	    public static void main(String[] args) {
	        //是插箱还是装箱是有jvm底层调用的。
	
	        //1.创建对象的方式 以 Integer为例；
	
	        //自动装箱
	        int a = 24;// 基本类型
	
	        // 自动向上提升；
	        Integer i = Integer.valueOf(a);
	        Integer i2 = new Integer(a);
	        Integer i3 = a;
	
	        System.out.println(i);
	        System.out.println(i2);
	        System.out.println(i3);
	
	        //自动插箱
	        int b; //基本类型
	        b=i; //其中的i是Intger类型
	        System.out.println(b);//相当于底层调用了 i.intValue();
	
	        int b2 = i2.intValue();
	        System.out.println(b2);
	
	    }
	}

吴琼老师

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java入门第十二节(二) 包装类

包装类1. 啥是包装类？基本数据类型没有任何方法，只是一个记录值，一个变量。 java是一种面向对象的编程语言，但是基本数据类型却不是面向对象的。数据类型之间又要经常发生转换，如：String 类与基本数据类型。怎么解决这样的问题！？这时候就需要功能更加完善的类，来替代基础类型。所以设计了更为贴近基本数据类型的代表类，叫做包装类。2. 基本类型与包装类对应关系包装类主要的作用就是，当做参数传递，和，方便与对象的操作。使用集合类型Collection时使用包装类型而非基本类型（
复制链接

扫一扫