Java -常用类 - 包装类介绍、8种基本数据类型手动装箱、拆箱

包装类分类 Wrapper(包装器)

1. 针对八种基本定义对应的引用类型 - 包装类
2. 有了类的特点，就可以调用类中的方法

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

返回

包装类继承体系图

返回

包装类基本类型转换

演示 包装类 和 基本数据类型的相互转换，这里以int 和 Integer演示

1. jdk5 前的手动装箱和拆箱方式，装箱：基本类型 -> 包装类型，反之，拆箱
2. jdk5 以后（含jdk5）的自动装箱和拆箱方式
3. 自动装箱底层调用的是valueOf方法，比如Integer.valueOf()

演示

package com.tao.wrapper_;

/**
 * Create By 刘鸿涛
 * 2022/1/1 13:30
 */
public class Integer01 {
    //演示int <--> Integer 的装箱和拆箱
    //jdk5前是手动装箱和拆箱
    //手动装箱      int -> Integer
    int n1 = 100;
    Integer integer = new Integer(n1);
    Integer integer1 = Integer.valueOf(n1);

    //手动拆箱
    //Integer -> Int
     int i = integer.intValue();

     //jdk5后，就可以自动装箱和自动拆箱
    int n2 = 200;
    //自动装箱 int -> Integer
    Integer integer2 = n2;  //底层使用的是 Integer.valueOf(n2)
    //自动拆箱 Integer -> int
    int n3 = integer2;      //底层仍然使用的是 intValue()方法
}

返回

8种基本数据类型手动装箱、拆箱

/**
 * create by 刘鸿涛
 * 2022/4/15 12:31
 */
@SuppressWarnings({"all"})
public class homework02 {
    public static void main(String[] args) {
        //int类型
        //装箱
        int i = 1;
        Integer integer = new Integer(i);
        //拆箱
        i = integer.intValue();

        //boolean类型
        //装箱
        boolean b = true;
        Boolean aBoolean = new Boolean(b);
        //拆箱
        boolean b1 = aBoolean.booleanValue();

        //char类型
        //装箱
        char c = '1';
        Character character = new Character(c);
        //拆箱
        c = character.charValue();

        //byte类型
        //装箱
        byte abyte = 1;
        Byte aByte = new Byte(abyte);
        //拆箱
        abyte = aByte.byteValue();

        //short类型
        //装箱
        short s = 1;
        Short aShort = new Short(s);
        //拆箱
        s = aShort.shortValue();

        //long类型
        //装箱
        long l = 1;
        Long aLong = new Long(l);
        //拆箱
        l = aLong.longValue();

        //float类型
        //装箱
        float f = 1;
        Float aFloat = new Float(f);
        //拆箱
        f = aFloat.floatValue();

        //double类型
        //装箱
        double d = 1.1;
        Double aDouble = new Double(d);
        //拆箱
         d = aDouble.doubleValue();

         //输出所有类型
        System.out.print(i + " " + d + " " + f + " " + c + " " + l + " " + s
        + " " + abyte + " " + b);
    }
}

包装类课堂练习

判断代码是否正确？

Double d = 100d	//ok,自动装箱 Double.valueOf(100d);
Float f = 1.5f;	//ok,自动装箱 Float.valueOf(1.5f);

如下两个题目输出结果相同吗？各是什么？

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

返回

包装类型和String类型的相互转换

package com.tao.wrapper_;

/**
 * Create By 刘鸿涛
 * 2022/1/1 14:11
 */
public class WrapperVSString {
    public static void main(String[] args) {
        //包装类(Integer) -> String
        Integer i = 100;    //自动装箱
        //方式1
        String str1 = i + "";   //得到字符串，对i没有影响
        //方式2
        String str2 = i.toString(); //直接toString
        //方式3
        String str3 = String.valueOf(i);
        
        //String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);    //使用自动装箱
        Integer i3 = new Integer(str4);         //构造器

    }
}

返回

Integer类和Character类的常用方法

package com.tao.wrapper_;

/**
 * Create By 刘鸿涛
 * 2022/1/1 14:20
 */
public class CommonMethod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);  //返回最小值 -2147483648
        System.out.println(Integer.MAX_VALUE);  //返回最大值 2147483647

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

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

返回

Inter类面试题

案例1

看看下面代码输出什么？

package com.tao.wrapper_;

/**
 * Create By 刘鸿涛
 * 2022/1/1 14:32
 */
public class WrapperExercise02 {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);     //比较对象地址，所以false

        //所以，这里主要是看范围 -128 ~ 127,直接返回
        Integer m = 1;                  //底层 Integer.valueOf(1); ->阅读源码  -128  -> 127
        Integer n = 1;                  //底层 Integer.valueOf(1);
        System.out.println(m == n);     //他们是同一个对象，而不是数字相等，因为没有越界，没有产生new

        Integer x = 128;                //越界，所以new Integer,新建对象
        Integer y = 128;                //越界，new Integer
        System.out.println(x == y);     //所以，对象不同，false
    }
}

案例2

看看下面代码输出什么

package com.tao.wrapper_;

/**
 * Create By 刘鸿涛
 * 2022/1/1 14:56
 */
public class WrapperExercise03 {
    public static void main(String[] args) {

        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);       //new 出来的就不是一个对象，false

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);       //同上false

        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);   //的确是一个对象 true

        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);   //这是两个对象  false

        Integer i9 = 127;       //数组中取出
        Integer i10 = new Integer(127); //这里new了
        System.out.println(i9 == i10);  //是两个对象 false

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

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

    }
}

返回