09-包装类笔记

包装类

5.1 概述

Java 提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于 java. Lang 包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean
除了这个 char he int型数据，别的都是首字母大写就好了
包装类总结来说就是以基本数据类型未标桩定义的对象包

5.2 Integer 类

• Integer 类概述
  包装一个对象中的原始类型 int 的值
• Integer 类构造方法及静态方法

方法名	说明
public Integer (int value)	根据 int 值创建 Integer 对象 (过时)
public Integer (String s)	根据 String 值创建 Integer 对象 (过时)
public static Integer valueOf (int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf (String s)	返回保存指定 String 值的 Integer 对象
static string tobinarystring (int i)	得到二进制
static string tooctalstring (int i)	得到八进制
static string toHexstring (int i)	得到十六进制
static int parseInt (string s)	将字符串类型的整数转成 int 类型的整数

    public static void main(String[] args) {
        Integer last1 = new Integer(10); //以前过时的创建方法
        Integer last2= new Integer("1234");  //也是过时的创建方法
        System.out.println(last1);  //10
        System.out.println(last2);  //1234

        //现在的Integer创建方式一般是用这个静态方法直接进行创建
        Integer now1 = Integer.valueOf(10);  //10
        Integer now2 = Integer.valueOf("4567");  //4567
        System.out.println(now1);
        System.out.println(now2);

        //包装类的进制转换
        /*
        * 下面这个也是一种静态方法
        * 主要作用是将这个里面传递的参数转化为一个自己定义的进制
        * */
        String binary= Integer.toBinaryString(10); //十进制
        String binary1= Integer.toOctalString(9); //八进制
        String binary2 = Integer.toHexString(17);//十六进制
        System.out.println(binary);//1010
        System.out.println(binary1);//11
        System.out.println(binary2);//11
    }

其中这个方法是不全的，对于这个 parse 转化，我们可以又 parseInt 也可以有 Double. parseDouble，也可以有 Boolean. parseBoolean
同样对于这个 toXXXString 方法，我们也有一个总方法就是 toString 方法，这个方法可以我们自己自定义这个进制

        String binary3 = Integer.toString(3,2);
        String binary4 = Integer.toString(9,8);
        String binary5 = Integer.toString(10,9);
        System.out.println(binary3);
        System.out.println(binary4);
        System.out.println(binary5);

但是要注意这个 Double 类型虽然也有这个 toString 方法，但是却不能进行进制转化
有关于进制转化的可以看这个文章。一个是 obsidian 的内链，一个是博客的链接
[[二进制, 八进制, 和十六进制的输入和输出]]
博客

5.3 装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

• 装箱：从基本类型转换为对应的包装类对象。
• 拆箱：从包装类对象转换为对应的基本类型。

用 Integer 与 int 为例：（看懂代码即可）
基本数值---->包装对象

Integer i = new Integer (4);//使用构造函数函数
Integer iii = Integer.ValueOf (4);//使用包装类中的 valueOf 方法

包装对象---->基本数值

int num = i.intValue ();

        int i = now1.intValue();
        int i2 = now2.intValue();
        byte a = now1.byteValue();
        byte b = now2.byteValue();
        System.out.println(i);
        System.out.println(i2);
        System.out.println(a);
        System.out.println(b);

对于这个装箱和拆箱的过程，其中拆箱其实就是对这个包装类的成员值变量进行了强制类型转化

    private final int value;
    public byte byteValue() {
        return (byte)value;
    }

对于这个装箱的过程，我们其实就是对这个包装类的内部成员进行赋值

	private final int value;
    public Integer(int value) {
        this.value = value;
    }

5.4 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从 Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：
Integer i = 4;//自动装箱。相当于 Integer i = Integer.ValueOf (4);
i = i + 5;//等号右边：将 i 对象转成基本数值 (自动拆箱) i.intValue () + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

5.5 基本类型与字符串之间的转换

基本类型转换为 String

• 转换方式
• 方式一：直接在数字后加一个空字符串
• 方式二：通过 String 类静态方法 valueOf()
• 示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");
    }
}

String 转换成基本类型

除了 Character 类之外，其他所有包装类都具有 parseXxx 静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的 byte 基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的 short 基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的 int 基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的 long 基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的 float 基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的 double 基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的 boolean 基本类型。

[!tip]

除了 Character 类之外，其他所有包装类都具有 parseXxx 静态方法可以将字符串参数转换为对应的基本类型；
为什么 Character 类没有呢
这是因为这些强制转化的参数都是字符串的类型
Character 类表示一个字符，而字符本身就是一个单个的字符，无法像整数或浮点数那样具有多个字符组成的表示形式。因此，从字符串中解析字符的需求不如解析整数或浮点数那样常见。
如果想将一个表示单个字符的字符串转换成 char 类型，可以使用 charAt 方法来提取其中的字符。例如：

String str = "A"; 
char c = str.charAt(0); 
System.out.println(c);  // 输出：A

代码使用（仅以 Integer 类的静态方法 parseXxx 为例）如：

• 转换方式
  • 方式一：先将字符串数字转成 Integer，再调用 valueOf ()方法
  • 方式二：通过 Integer 静态方法 parseInt ()进行转换
• 示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
    
}

[!warning]

如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出 java.lang.NumberFormatException 异常。