参考笔记：java 包装类 万字详解（通俗易懂)_java包装类-CSDN博客
目录
1.简介
基本数据类型不是对象，不能使用类的方法；因此， Java 针对基本类型提供了它们对应的包装类，八大基本数据类型，对应了八种包装类，以对象的形式来调用。包装类有了类的特点，使得可以调用包装类中的方法
八大包装类位于 java.lang 包下，如下图所示：
除了 Integer 和 Character 这两个包装类外，其他六个包装类的类名均是对应的基本类型首字母大写后得到的
2.包装类的继承关系图
蓝色实线：继承extends
绿色虚线：实现implements
① Byte、Integer、Long、Float、Double、Short 的继续关系图
② Boolean 的继承关系图
③ Character 的继承关系图
3.装箱和拆箱
3.1 介绍
装箱：基本类型 ——> 包装类型（或者叫对象类型，引用类型）
拆箱：包装类型 ——> 基本类型
3.2 手动拆装箱
在 JDK5.0 之前，拆装箱均是程序员手动完成的
手动装箱：可以使用包装类的构造器完成，也可以使用 valueOf() 方法
手动拆箱：以 Integer 类为例，需要用到 intValue() 方法；以 Character 类为例，需要用到 charValue() 方法
案例1：Integer包装类的手动拆装箱过程
public class demo {
public static void main(String[] args) {
//JDK5.0之前，拆装箱都是手动完成
int temp = 19;
//手动装箱(基本类型 ————> 包装/引用类型)
Integer integer_0 = new Integer(temp);//使用包装类的构造器完成装箱
Integer integer_1 = Integer.valueOf(temp);//使用包装类的valueOf方法完成装箱
//手动拆箱(包装/引用类型 ————> 基本类型)
int tempI_0 = integer_0.intValue();//使用包装类的intValue方法完成拆箱
System.out.println("integer_0的值 = " + integer_0);
System.out.println("integer_1的值 = " + integer_1);
System.out.println("tempI_0 = " + tempI_0);
}
}案例1运行结果
案例2：Boolean包装类的手动拆装箱过程
public class demo {
public static void main(String[] args) {
//JDK5.0之前，拆装箱都是手动完成
char temp = 'a';
//手动装箱(基本类型 ————> 包装/引用类型)
Character character_1 = new Character(temp);//使用包装类的构造器完成装箱
Character character_2 = Character.valueOf(temp);//使用包装类的valueOf方法完成装箱
//手动拆箱(包装/引用类型 ————> 基本类型)
char tempI_0 = character_1.charValue();//使用包装类的charValue方法完成拆箱
System.out.println("character_1的值 = " + character_1);
System.out.println("character_2的值 = " + character_2);
System.out.println("tempI_0 = " + tempI_0);
}
}案例2的执行结果
3.3. 自动拆装箱
从 JDK5.0 开始，Java 提供了自动拆装箱的机制（不需要手动调用构造器或者方法了）
自动装箱：实际上底层调用了 valueOf() 方法
手动拆箱：实际上底层调用了 intValue()方法（以Integer包装类为例）
案例：Integer包装类的自动拆装箱
public class demo {
public static void main(String[] args) {
//JDK5.0以后，java提供了自动拆装箱
Integer integer_1 = 199; //（自动）装箱——其实底层调用的仍然是valueOf方法（可Debug）
int tempI_1 = integer_1; //（自动）拆箱——其实底层调用的仍然是intValue方法
System.out.println("integer_1的值 = " + integer_1);
System.out.println("tempI_1 = " + tempI_1);
System.out.println("----------------------------------");
}
}运行结果
Debug验证自动拆装箱是否在底层调用了手动拆装箱时用到的方法：valueOf、intValue
由上面的 GIF 可以看到，自动装拆箱底层分别调用了valueOf() 方法、intValue()方法
另外，关于 Integer 的 valueOf() 方法源码如下 :
@IntrinsicCandidate
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}源码的 valueOf 方法中有一个 if 条件语句的判断，它的意思是：如果传入的 int 基本类型的值在这个范围内，就不 new 新的 Integer 对象，而是调用底层的用 static final 修饰的 Integer 缓冲数组 cache。通过追溯源码，可以得知这里的 low 和 high 的实际范围是 -128 ~ 127，如下图所示 :
缓冲数组 cache 中存放的元素是[-128，127]。可以通过 Debug 来看看底层的缓冲数组是否真实存在，如下GIF所示 :
4.关于String类型的转化问题
4.1 String类型和基本类型的相互转化
4.1.1 String ——> 基本类型
包装类中的 parseXxx 方法可以将字符串类型的数据转换成对应的基本类型，需要用相应的基本类型来作接收
需要注意的是，在将字符串类型转为其他基本类型前，一定要确认字符串里面的内容能否正常转换，比方说，如果想把 "唱跳rap篮球" 这段字符串转换为 int 类型，这时候一定会发生数字格式异常，如下图所示 :
String ——> 基本类型演示（byte、short、int、long、float、double、boolean）
public class demo {
public static void main(String[] args) {
//parseXxx(String)，以对应的基本类型作接收
byte temp_byte = Byte.parseByte("11");
short temp_short = Short.parseShort("141");
int temp_int = Integer.parseInt("430");
long temp_long = Long.parseLong("11211");
float temp_float = Float.parseFloat("66.66F");
double temp_double = Double.parseDouble("666.666");
boolean temp_boolean = Boolean.parseBoolean("true");
System.out.println("temp_byte = " + temp_byte);
System.out.println("temp_short = " + temp_short);
System.out.println("temp_int = " + temp_int);
System.out.println("temp_long = " + temp_long);
System.out.println("temp_float = " + temp_float);
System.out.println("temp_double = " + temp_double);
System.out.println("temp_boolean = " + temp_boolean);
}
}运行结果：
String ——> char 演示
在八大包装类中，除了 Character 类外，其他的 7 种包装类中都有 parseXxx 方法。如果想将 String 字符串类型的数据转换成 char 类型的数据，可以通过 String 类中的两个方法来完成：
① char[] toCharArray() : 将字符串转换成字符数组
② char charAt(int index) : 获取指定索引位置的字符
public class demo {
public static void main(String[] args) {
//定义一个字符串
String str = "蔡徐坤";
//利用toCharArray() 方法将字符串转换为字符数组
char[] charArray = str.toCharArray();
System.out.println("string字符串一共有" + charArray.length + "个字符.");
for (int i = 0; i < charArray.length; i++) {
System.out.println("第" + (i + 1) + "个字符是：" + charArray[i]);
}
System.out.println("---------------------------------------");
//利用charAt方法来直接获取字符串中的每一个字符元素
char temp_char_0 = str.charAt(0);
char temp_char_1 = str.charAt(1);
char temp_char_2 = str.charAt(2);
System.out.println("string字符串第一个元素为：" + temp_char_0);
System.out.println("string字符串第二个元素为：" + temp_char_1);
System.out.println("string字符串第三个元素为：" + temp_char_2);
}
}运行结果：
4.1.2 基本类型 ——> String
基本类型转 String 最常见的两种方式：
① 直接与空字符串进行拼接
② String类的valueOf方法
案例
public class demo {
public static void main(String[] args) {
//方法一 : 以空字符串拼接的形式
//byte --> String
byte temp_byte = 127;
String temp_string_0 = 127 + "";
//short --> String
short temp_short = 141;
String temp_string_1 = temp_short + "";
//int --> String
int temp_int = 428;
String temp_string_2 = temp_int + "";
//long --> String
long temp_long = 11211;
String temp_string_3 = temp_long + "";
//float --> String
float temp_float = 135.0F;
String temp_string_4 = temp_float + "";
//double --> String
double temp_double = 433.0;
String temp_string_5 = temp_double + "";
//char --> String
char temp_char = 'A';
String temp_string_6 = temp_char + "";
//boolean --> String
boolean temp_boolean = true;
String temp_string_7 = temp_boolean + "";
System.out.println("temp_string_0 = " + temp_string_0);
System.out.println("temp_string_1 = " + temp_string_1);
System.out.println("temp_string_2 = " + temp_string_2);
System.out.println("temp_string_3 = " + temp_string_3);
System.out.println("temp_string_4 = " + temp_string_4);
System.out.println("temp_string_5 = " + temp_string_5);
System.out.println("temp_string_6 = " + temp_string_6);
System.out.println("temp_string_7 = " + temp_string_7);
System.out.println("========================================");
//方法二 : 利用String类的valueOf方法
temp_string_0 = String.valueOf(temp_byte) + "_EX";
temp_string_1 = String.valueOf(temp_short) + "_EX";
temp_string_2 = String.valueOf(temp_int) + "_EX";
temp_string_3 = String.valueOf(temp_long) + "_EX";
temp_string_4 = String.valueOf(temp_float) + "_EX";
temp_string_5 = String.valueOf(temp_double) + "_EX";
temp_string_6 = String.valueOf(temp_char) + "_EX";
temp_string_7 = String.valueOf(temp_boolean) + "_EX";
System.out.println("temp_string_0 = " + temp_string_0);
System.out.println("temp_string_1 = " + temp_string_1);
System.out.println("temp_string_2 = " + temp_string_2);
System.out.println("temp_string_3 = " + temp_string_3);
System.out.println("temp_string_4 = " + temp_string_4);
System.out.println("temp_string_5 = " + temp_string_5);
System.out.println("temp_string_6 = " + temp_string_6);
System.out.println("temp_string_7 = " + temp_string_7);
}
}4.2 String类型和包装类型的相互转化
4.2.1 String ——> 包装类
String 类转化为包装类有 2 种方式：
① 利用包装类的parseXXX，例如：Integer integer_0 = Integer. parseInt(字符串类型变量);
② 利用包装类的构造器，例如 : Integer integer_1 = new Integer(字符串类型变量);
补充：方式 ① 中用到了 parseInt 方法，而在上文 String 类型转基本类型时也用到了 parseInt 方法，但当时是用 int 类型变量来作接收的。先看一下 parseInt 的源码：
可以看到 parseInt 的返回值类型是 int 类型，因此方式 ① 实际上应用了自动装箱，把等号右边返回的 int 类型的值，在底层又调用 valueOf 方法装箱成了 Integer 包装类
案例
public class demo {
public static void main(String[] args) {
//演示 : String类型 ————> 包装类型
//方式一
String string_0 = "141";
Integer integer_0 = Integer.parseInt(string_0);
//方式二
String string_1 = "133";
Integer integer_1 = new Integer(string_1);
System.out.println("integer_0的值 = " + integer_0);
System.out.println("integer_1的值 = " + integer_1);
}
}4.2.2 包装类 ——> String
包装类转换为 String 类型有 3 种方式：
① String xxx = 包装类变量名 + ""；
② String xxx = 包装类类名.toString()；
③ String xxx = String.valueOf(...)；
方式 ① 和上文中提到的基本类型转 String 类型的方式是一回事
方式 ② 体现出包装类相对于基本类型的优势，可以直接调用包装类中的方法
方式 ③ 使用的是 String 的 valueOf 方法，valueOf 内部调用的就是包装类的 toString 方法，源码如下：
案例：Integer ——> String
public class demo{
public static void main(String[] args){
Integer integer_0 = 146;//自动装箱
//包装类->String类的三种方式
String str1 = integer_0 + "";//方式1
String str2 = Integer.toString(integer_0);//方式2
String str3 = String.valueOf(integer_0);//方式3
System.out.println("str1 = " + str1);
System.out.println("str2 = " + str2);
System.out.println("str3 = " + str3);
}
}5.八大包装类的常用成员方法
每个包装类下的方法都很多，本文只讲一些比较常用的，遇到不懂的问问 GPT 或者 DeepSeek 就行了。查看其方法可以通过如下步骤：
5.1 Byte类常用方法
① byte byteValue() ：返回当前 Byte 类对象对应的值，以 byte 类型作接收
② static int compare(byte x, byte y) ：比较两个 byte 变量的值。返回值：前面 byte 变量的值减去后面 byte 变量的值
③ int compareTo(Byte anotherByte)：比较两个 Byte 类对象的值，返回值同 ②
④ double doubleValue() ：返回当前 Byte 类对象对应的值，以 double 类型作接收
⑤ int intValue()：返回当前 Byte 类对象对应的值，以 int 类型作接收
⑥ static int parseByte(String xxx)： 字符串类型 ——> byte 类型
⑦ String toString()：将当前 Byte 对象的值转换为 String 类型
⑧ static String toString(byte b)：将指定的 byte 值转换为 String 对象
⑨ static Byte valueOf(...)：字符串类型 ——> Byte 类型
案例演示
public class demo {
public static void main(String[] args) {
//演示 : Byte类常用方法
//1 —— byte byteValue() : 返回当前Byte类对象对应的值，以byte类型作接收
Byte b = 127; //自动装箱
byte bb = b.byteValue();
System.out.println("byte类型变量bb = " + bb);
System.out.println("----------------------------------");
//2 —— static int compare(byte x, byte y) : 比较两个byte变量的值, 返回值为前面byte变量的值减去后面byte变量的值
byte temp_b_0 = 5;
byte temp_b_1 = 1;
int i = Byte.compare(temp_b_0, temp_b_1);
System.out.println("temp_b_0 - temp_b_1 = " + i);
System.out.println("----------------------------------");
//3 —— int compareTo(Byte anotherByte) : 比较两个Byte类对象的值，返回值同方法2
Byte temp_B_0 = 55;
Byte temp_B_1 = 11;
int i1 = temp_B_0.compareTo(temp_B_1);
System.out.println("temp_B_0 - temp_B_1 = " + i1);
System.out.println("----------------------------------");
//4 —— double doubleValue() : 返回当前Byte类对象对应的值，以double类型作接收
double bb1 = b.doubleValue();
System.out.println("double类型变量bb1 = " + bb1);
System.out.println("----------------------------------");
//5 —— int intValue() : 返回当前Byte类对象对应的值，以int类型作接收
int bb2 = b.intValue();
System.out.println("int类型变量bb2 = " + bb2);
System.out.println("----------------------------------");
//6 —— static int parseByte(String xxx) : 字符串类型 ——> byte类型
byte temp_b_2 = Byte.parseByte("1");
System.out.println("byte类型变量temp_b_2 = " + temp_b_2);
System.out.println("----------------------------------");
//7 —— String toString() : 将当前Byte对象的值转换为String类型
Byte temp_B_2 = 127;
String string_0 = temp_B_2.toString();
System.out.println("Byte类型对象temp_B_2的字符串形式为：" + string_0);
System.out.println("----------------------------------");
//8 —— static String toString(byte b) : 将指定的byte值转换为String对象
byte temp_b_3 = 2;
String string_1 = Byte.toString(temp_b_3);
System.out.println("byte类型变量temp_b_3的字符串形式为：" + string_1);
System.out.println("----------------------------------");
//9 —— static Byte valueOf(...) : 字符串类型 ——> Byte类型
Byte temp_B_3 = Byte.valueOf("11");
System.out.println("Byte类型对象temp_B_3的值 = " + temp_B_3);
}
}5.2 Short类常用方法
① Short.MIN_VALUE、Short.MAX_VALUE：返回 Short/short 类型的最小值、最大值
② short shortValue()：返回当前 Short 类对象对应的值，以 short 类型作接收
③ static int compare(short x, short y)：比较两个 short 变量的值, 返回值：前面 short 变量的值减去后面 short 变量的值
④ int compareTo(Short anotherShort)：比较两个 Short 类对象的值，返回值同 ③
⑤ double doubleValue()：返回当前 Short 类对象对应的值，以 double 类型作接收
⑥ int intValue()：返回当前 Short 类对象对应的值，以 int 类型作接收
⑦ static int parseShort(String xxx) : 字符串类型 ——> short 类型
⑧ String toString()：将当前 Short 对象的值转换为 String 类型
⑨ static String toString(short s)：将指定的 short 值转换为 String 对象
⑩ static Short valueOf(...)：字符串类型 ——> Short 类型
案例演示
public class demo {
public static void main(String[] args) {
//演示Short类常用方法
//1 —— Short.MIN_VALUE,Short.MAX_VALUE,返回Short/short类型的最小值、最大值
System.out.println(Short.MIN_VALUE);
System.out.println(Short.MAX_VALUE);
System.out.println("------------------------------------");
//2 —— short shortValue() : 返回当前Short对象的值，以short基本类型作接收
Short temp_S_0 = 128; //自动装箱
short temp_s_0 = temp_S_0.shortValue();
System.out.println("short类型变量temp_s_0 = " + temp_s_0);
System.out.println("------------------------------------");
//3 —— static int compare(short x, short y) : 比较两个short变量的值, 返回值为前面short变量的值减去后面short变量的值
short temp_s_1 = 6;
short temp_s_2 = 3;
int i = Short.compare(temp_s_1, temp_s_2);
System.out.println("temp_s_1 - temp_s_2 = " + i);
System.out.println("------------------------------------");
//4 —— int compareTo(Short anotherShort) : 比较两个Short类对象的值，返回值同3
Short temp_S_1 = 66;
Short temp_S_2 = 33;
int i1 = temp_S_1.compareTo(temp_S_2);
System.out.println("temp_S_1 - temp_S_2 = " + i1);
System.out.println("------------------------------------");
//5 —— double doubleValue() : 返回当前Short对象的值，以double基本类型作接收
double temp_d_0 = temp_S_0.doubleValue();
System.out.println("double类型变量temp_d_0 = " + temp_d_0);
System.out.println("------------------------------------");
//6 —— int intValue() : 返回当前Short对象的值，以int基本类型作接收
int temp_i_0 = temp_S_0.intValue();
System.out.println("int类型变量temp_i_0 = " + temp_i_0);
System.out.println("------------------------------------");
//7 —— static int parseShort(String xxx) : 字符串类型 ——> short基本类型
short temp_s_3 = Short.parseShort("128");
System.out.println("short类型变量temp_s_3 = " + temp_s_3);
System.out.println("------------------------------------");
//8 —— String toString() : 将当前Short对象的值转换为String类型
Short temp_S_3 = 1277;
String string_0 = temp_S_3.toString();
System.out.println("Short类型对象temp_S_3的字符串形式为：" + string_0);
System.out.println("------------------------------------");
//9 —— static String toString(short s) : 将指定的short值转换为String对象
short temp_s_4 = 2;
String string_1 = Short.toString(temp_s_4);
System.out.println("short类型变量temp_s_4的字符串形式为：" + string_1);
System.out.println("----------------------------------");
//10 —— static Short valueOf(...) : 字符串类型 ——> Short类型
Short temp_S_4 = Short.valueOf("1111");
System.out.println("Short类型对象temp_S_4的值 = " + temp_S_4);
}
}5.3 Integer类常用方法
① Integer.MIN_VALUE、Integer.MAX_VALUE：返回 Integer/int 类型的最小值、最大值
② int intValue() 、double doubleValue()：返回当前 Integer 类对象对应的值，以 int/double 类型作接收
③ static int compare(int x, int y)： 比较两个 int 变量的值。返回值：如果前一个数大，返回 1 ；如果前一个数小，返回 -1 ；相等则返回 0
④ int compareTo(Integer anotherInteger)：比较两个 Integer 类对象的值，返回值同 ③
⑤ static int parseInt(String xxx)：字符串类型 ——> int 类型
⑥ String toString()： 将当前 Integer 对象的值转换为 String 类型
⑦ static String toString(short s)：将指定的 int 值转换为 String 对象
⑧ static Short valueOf(...)：字符串类型 ——> Integer 类型
⑨ static int max(int x, int y) 和 min(int x, int y)：获取两个数中的最大值和最小值
⑩ static int sum(int x, int y)：返回（x + y）的值
案例演示
public class demo {
public static void main(String[] args) {
//演示Integer类常用方法
//1 —— Integer.MIN_VALUE,Integer.MAX_VALUE,返回Integer/int类型的最小值、最大值
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);
System.out.println("------------------------------------");
//2 —— int intValue()、double doubleValue() : 返回当前Integer对象的值，以int/double基本类型作接收
Integer temp_I_0 = 1280; //自动装箱
int temp_i_0 = temp_I_0.intValue();
double temp_d_0 = temp_I_0.doubleValue();
System.out.println("int类型变量temp_i_0 = " + temp_i_0);
System.out.println("double类型变量temp_d_0 = " + temp_d_0);
System.out.println("------------------------------------");
//3 —— static int compare(int x, int y) : 比较两个int变量的值。如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0
int temp_i_1 = 7;
int temp_i_2 = 11;
int i = Integer.compare(temp_i_1, temp_i_2);
System.out.println("temp_i_1和temp_i_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i);
System.out.println("------------------------------------");
//4 —— int compareTo(Integer anotherInteger) : 比较两个Integer类对象的值，返回值同方法3
Integer temp_I_1 = 77;
Integer temp_I_2 = 11;
int i1 = temp_I_1.compareTo(temp_I_2);
System.out.println("temp_I_1和temp_I_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i1);
System.out.println("------------------------------------");
//5 —— static int parseInt(String xxx) : 字符串类型 ——> int基本类型
int temp_i_3 = Integer.parseInt("4444");
System.out.println("int类型变量temp_i_3 = " + temp_i_3);
System.out.println("------------------------------------");
//6 —— String toString() : 将当前Integer对象的值转换为String类型
Integer temp_I_3 = 11217;
String string_0 = temp_I_3.toString();
System.out.println("Integer类型对象temp_I_3的字符串形式为：" + string_0);
System.out.println("------------------------------------");
//7 —— static String toString(int s) : 将指定的int值转换为String对象
int temp_i_4 = 111111;
String string_1 = Integer.toString(temp_i_4);
System.out.println("int类型变量temp_i_4的字符串形式为：" + string_1);
System.out.println("----------------------------------");
//8 —— static Integer valueOf(...) : 字符串类型 ——> Integer类型
Integer temp_I_4 = Integer.valueOf("1111");
System.out.println("Integer类型对象temp_I_4的值 = " + temp_I_4);
System.out.println("----------------------------------");
//9 —— static int max(int x, int y) 和 min(int x, int y) : 获取两个数中的最大值和最小值
System.out.println("100和101哪个数更大？" + Integer.max(100, 101));
System.out.println("200和201哪个数更小？" + Integer.min(200, 201));
System.out.println("----------------------------------");
//10 —— static int sum(int x, int y) : 返回（x + y）的值
System.out.println("100 + 201 = " + Integer.sum(100 ,201));
}
}5.4 Long类常用方法
① Long.MIN_VALUE、Long.MAX_VALUE：返回 Long/long 类型的最小值、最大值
② long longValue()、int intValue() 、double doubleValue()：返回当前 Long 类对象对应的值，以 long/int/double 类型作接收
③ static int compare(long x, long y)：比较两个 long 变量的值。返回值：如果前一个数大，返回 1 ；如果前一个数小，返回 -1 ；相等则返回 0
④ int compareTo(Long anotherLong)：比较两个 Long 类对象的值，返回值同 ③
⑤ static long parseLong(String xxx)：字符串类型 ——> long 类型
⑥ String toString()：将当前 Long 对象的值转换为 String 类型
⑦ static String toString(long l)：将指定的 long 值转换为 String 对象
⑧ static Long valueOf(...)：字符串类型 ——> Long 类型
⑨ static long max(long x, long y) 和 min(long x, long y)：获取两个数中的最大值和最小值
⑩ static long sum(long x, long y)：返回（x + y）的值
案例演示
public class demo {
public static void main(String[] args) {
//演示Long类常用方法
//1 —— Long.MIN_VALUE,Long.MAX_VALUE,Long/long类型的最小值、最大值
System.out.println(Long.MIN_VALUE);
System.out.println(Long.MAX_VALUE);
System.out.println("------------------------------------");
//2 —— long longValue()、int intValue()、double doubleValue(): 返回当前Long对象的值，以long/int/double基本类型作接收
Long temp_L_0 = 2224L; //自动装箱
long temp_l_0 = temp_L_0.longValue();
int temp_i_0 = temp_L_0.intValue();
double temp_d_0 = temp_L_0.doubleValue();
System.out.println("long类型变量temp_l_0 = " + temp_l_0);
System.out.println("int类型变量temp_i_0 = " + temp_i_0);
System.out.println("double类型变量temp_d_0 = " + temp_d_0);
System.out.println("------------------------------------");
//3 —— static int compare(long x, long y) : 比较两个long变量的值. 如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0
long temp_l_1 = 222L;
long temp_l_2 = 111L;
int i = Long.compare(temp_l_1, temp_l_2);
System.out.println("temp_l_1和temp_l_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i);
System.out.println("------------------------------------");
//4 —— int compareTo(Long anotherLong) : 比较两个Long类对象的值，返回值同方法3
Long temp_L_1 = 773L;
Long temp_L_2 = 113L;
int i1 = temp_L_1.compareTo(temp_L_2);
System.out.println("temp_L_1和temp_L_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i1);
System.out.println("------------------------------------");
//5 —— static long parseLong(String xxx) : 字符串类型 ——> long基本类型
long temp_l_3 = Long.parseLong("35252");
System.out.println("long类型变量temp_l_3 = " + temp_l_3);
System.out.println("------------------------------------");
//6 —— String toString() : 将当前Long对象的值转换为String类型
Long temp_L_3 = 11217L;
String string_0 = temp_L_3.toString();
System.out.println("Long类型对象temp_L_3的字符串形式为：" + string_0);
System.out.println("------------------------------------");
//7 —— static String toString(long l) : 将指定的long值转换为String对象
long temp_l_4 = 222222;
String string_1 = Long.toString(temp_l_4);
System.out.println("long类型变量temp_l_4的字符串形式为：" + string_1);
System.out.println("----------------------------------");
//8 —— static Long valueOf(...) : 字符串类型 ——> Long类型
Long temp_L_4 = Long.valueOf("111241");
System.out.println("Long类型对象temp_L_4的值 = " + temp_L_4);
System.out.println("----------------------------------");
//9 —— static long max(long x, long y) 和 min(long x, long y) : 获取两个数中的最大值和最小值
System.out.println("10000和10100哪个数更大？" + Long.max(10000, 10100));
System.out.println("20000和20100哪个数更小？" + Long.min(20000, 20100));
System.out.println("----------------------------------");
//10 —— static long sum(long x, long y) : 返回（x + y）的值
System.out.println("11111111 + 8888889 = " + Long.sum(11111111 ,8888889));
}
}5.5 Character类常用方法
① char charValue()：返回当前 Character 类对象对应的值，以 char 类型作接收
② static Character valueOf(...)：字符串类型 ——> Character 类型
③ static int compare(char x, char y)：比较两个 Character 类对象的字符。返回值： x 的 ASCII 码值 - y 的 ASCII 码值
④ int compareTo(Character anotherCharater)：比较两个 Character 类对象的值，返回值同 ③
⑤
（1）static boolean isDigit(char c1) : 判断该字符是不是数字 （2）static boolean isLetter(char c2) : 判断该字符是不是字母 （3）static boolean isUpperCase(char c3) : 判断该字符是不是大写形式 （4）static boolean isLowerCase(char c4) : 判断该字符是不是小写形式 （5）static boolean isWhitespace(char c5) : 判断该字符是不是空格
⑥
（1）static char toUpperCase(char c) : 将该字符转换为大写形式，以char类型作接收 （2）static char toLowerCase(char c) : 将该字符转换为小写形式，以char类型作接收
案例演示
public class demo {
public static void main(String[] args) {
//演示 : Character类常用方法
//1 —— char charValue():返回当前Character类对象对应的值，以char类型作接收
Character character_0 = '蔡';//自动装箱
char char_0 = character_0.charValue();
System.out.println("char基本类型变量char_0 = " + char_0);
System.out.println("----------------------------------");
//2 —— static Character valueOf(...) :字符串类型 ——> Character类型
Character character_1 = Character.valueOf('S');
System.out.println("Character类对象character_1的字符是：" + character_0);
System.out.println("----------------------------------");
//3 —— static int compare(char x, char y) : 返回前面字符ASCII码值 - 后面字符ASCII值的int类型
int i1 = Character.compare('A', 'F');
System.out.println("ASCII码值'A' - 'F' = " + i1);
System.out.println("----------------------------------");
//4 —— int compareTo(Character anotherCharacter) : 比较两个Character类对象的字符，返回值同方法2
Character character_2 = 'a';
Character character_3 = 'd';
int i2 = character_2.compareTo(character_3);
System.out.println("character_2 - character_3 = " + i2);
System.out.println("----------------------------------");
/*5
—— static boolean isDigit(char c1) : 判断该字符是不是数字
—— static boolean isLetter(char c2) : 判断该字符是不是字母
—— static boolean isUpperCase(char c3) : 判断该字符是不是大写形式
—— static boolean isLowerCase(char c4) : 判断该字符是不是小写形式
—— static boolean isWhitespace(char c5) : 判断该字符是不是空格
*/
System.out.println("\'A\'是不是数字 : " + Character.isDigit('A'));
System.out.println("\'A\'是不是字母 : " + Character.isLetter('A'));
System.out.println("\'A\'是不是大写形式 : " + Character.isUpperCase('A'));
System.out.println("\'A\'是不是小写形式 : " + Character.isLowerCase('A'));
System.out.println("\'A\'是不是空格 : " + Character.isWhitespace('A'));
System.out.println("----------------------------------");
/*6
—— static char toUpperCase(char c) : 将该字符转换为大写形式，以char类型作接收
—— static char toLowerCase(char c) : 将该字符转换为小写形式，以char类型作接收
*/
char c1 = Character.toUpperCase('n');
char c2 = Character.toLowerCase('B');
System.out.println("\'n\'字符的大写形式为：" + c1);
System.out.println("\'B\'字符的小写形式为：" + c2);
}
}5.6 Float类常用方法
① Float.MIN_VALUE、Float.MAX_VALUE：返回 Float/float 类型的最小值、最大值
② float floatValue()、int intValue() 、long doubleValue()、double doubleValue()：返回当前 Float 类对象对应的值，以 float/int/long/double 类型作接收
③ static int compare(float x, float y)：比较两个 float 变量的值。返回值：如果前一个数大，返回 1 ；如果前一个数小，返回 -1 ；相等则返回 0
④ int compareTo(Float anotherFloat)：比较两个 Float 类对象的值，返回值同 ③
⑤ static float parseFloat(String xxx)：字符串类型 ——> float 类型
⑥ String toString()：将当前 Float 对象的值转换为 String 类型
⑦ static String toString(float f)：将指定的 float 值转换为 String 对象
⑧ static Float valueOf(...)：字符串类型 ——> Float 类型
⑨ static float max(float x, float y) 和 min(float x, float y)：获取两个数中的最大值和最小值
⑩ static float sum(float x, float y)：返回（x + y）的值
案例演示
public class demo {
public static void main(String[] args) {
//演示 : Float类常用方法
//1 —— Float.MIN_VALUE,Float.MAX_VALUE,Float/float类型的最小值、最大值
System.out.println(Float.MIN_VALUE);
System.out.println(Float.MAX_VALUE);
System.out.println("------------------------------------");
//2 —— float floatValue()、int intValue()、long longValue()、double doubleValue: 返回当前Float对象的值，以float/int/long/double基本类型作接收。
Float temp_F_0 = 1024.11F;//自动装箱
float temp_f_0 = temp_F_0.floatValue();
int temp_i_0 = temp_F_0.intValue();
long temp_l_0 = temp_F_0.longValue();
double temp_d_0 = temp_F_0.doubleValue();
System.out.println("float类型变量temp_f_0 = " + temp_f_0);
System.out.println("int类型变量temp_i_0 = " + temp_i_0);
System.out.println("long类型变量temp_l_0 = " + temp_l_0);
System.out.println("double类型变量temp_d_0 = " + temp_d_0);
System.out.println("------------------------------------");
//3 —— static int compare(float x, float y) : 比较两个float变量的值, 如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0
float temp_f_1 = 222.11F;
float temp_f_2 = 222.11F;
int i = Float.compare(temp_f_1, temp_f_2);
System.out.println("temp_f_1和temp_f_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i);
System.out.println("------------------------------------");
//4 —— int compareTo(Float anotherFloat) : 比较两个Float类对象的值，返回值同方法3
Float temp_F_1 = 222.11F;
Float temp_F_2 = 123.11F;
int i1 = temp_F_1.compareTo(temp_F_2);
System.out.println("temp_F_1和temp_F_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i1);
System.out.println("------------------------------------");
//5 —— static float parseFloat(String xxx) : 字符串类型 ——> float基本类型
float temp_f_3 = Float.parseFloat("35252.11125");
System.out.println("float类型变量temp_f_3 = " + temp_f_3);
System.out.println("------------------------------------");
//6 —— String toString() : 将当前Float对象的值转换为String类型
Float temp_F_3 = 12144217.12F;
String string_0 = temp_F_3.toString();
System.out.println("Float类型对象temp_F_3的字符串形式为：" + string_0);
System.out.println("------------------------------------");
//7 —— static String toString(float f) : 将指定的float值转换为String对象
float temp_f_4 = 222222.11F;
String string_1 = Float.toString(temp_f_4);
System.out.println("float类型变量temp_f_4的字符串形式为：" + string_1);
System.out.println("----------------------------------");
//8 —— static Float valueOf(...) : 字符串类型 ——> Float类型
Float temp_F_4 = Float.valueOf("111241.1235");
System.out.println("Float类型对象temp_F_4的值 = " + temp_F_4);
System.out.println("----------------------------------");
//9 —— static float max(float x, float y) 和 min(float x, float y) : 获取两个数中的最大值和最小值
System.out.println("10000.00 和 10100.11, 哪个数更大？" + Float.max(10000.00F, 10100.11F));
System.out.println("200.00 和 201.88, 哪个数更小？" + Float.min(200.00F, 201.88F));
System.out.println("----------------------------------");
//10 —— static float sum(float x, float y) : 返回（x + y）的值
System.out.println("11111.11 + 8889.022 = " + Float.sum(11111.11F,8889.022F));
}
}5.7 Double类常用方法
与 Float 类完全一致，这里不再赘述
5.8 Boolean类常用方法
① boolean booleanValue()：返回当前 Boolean 类对象对应的值，以 boolean 类型作接收
② static int compare(boolean x，boolean y)：比较两个 boolean 变量的值，两个变量真值相同返回 0 .否则返回值取决于于第一个 boolean 变量的真值，true 返回 1 ，false 返回 -1
③ int compareTo(Boolean anotherBoolean)：比较两个 Boolean 类对象的值，返回值同 ②
④ static boolean parseBoolean(String xxx)：字符串类型 ——> boolean 类型
⑤ String toString()：将当前 Boolean 对象的值转换为 String 类型
⑥ static String toString(boolean b)：将指定的 boolean 值转换为 String 对象
⑦ static Boolean valueOf(...) ：字符串类型 ——> Boolean 类型
案例演示
public class demo {
public static void main(String[] args) {
//演示 : Boolean类常用方法
//1 —— boolean booleanValue()：返回当前Boolean类对象对应的值，以boolean类型作接收
Boolean temp_B_0 = true;//自动装箱
boolean temp_b_0 = temp_B_0.booleanValue();
System.out.println("boolean类型变量temp_b_0 = " + temp_b_0);
System.out.println("------------------------------------");
//2 —— static int compare(boolean x, boolean y) : 比较两个boolean变量的值,两个变量真值相同返回0。否则返回值取决于第一个boolean变量的真值，true返回1，false返回-1.
boolean temp_b_1 = false;
boolean temp_b_2 = true;
int i = Boolean.compare(temp_b_1, temp_b_2);
int ii = Boolean.compare(temp_b_2, temp_b_1);
int iii = Boolean.compare(temp_b_2, temp_b_2);
System.out.println("temp_b_1和temp_b_2, 两个真值相同返回1。否则返回值取决于传入第一个boolean变量的真值，true返回1，false返回-1 : " + i);
System.out.println("temp_b_2和temp_b_1, 两个真值相同返回1。否则返回值取决于传入第一个boolean变量的真值，true返回1，false返回-1 : " + ii);
System.out.println("temp_b_2和temp_b_2, 两个真值相同返回1。否则返回值取决于传入第一个boolean变量的真值，true返回1，false返回-1 : " + iii);
System.out.println("------------------------------------");
//3 —— int compareTo(Boolean anotherBoolean) : 比较两个Boolean类对象的值，返回值同方法2
Boolean temp_B_1 = false;
Boolean temp_B_2 = false;
int i1 = temp_B_1.compareTo(temp_B_2);
System.out.println("temp_B_1和temp_B_2的真值情况是 : " + i1);
System.out.println("------------------------------------");
//4 —— static boolean parseBoolean(String xxx) : 字符串类型 ——> boolean基本类型
boolean temp_b_3 = Boolean.parseBoolean("666");
System.out.println("boolean类型变量temp_b_3 = " + temp_b_3);
System.out.println("------------------------------------");
//5 —— String toString() : 将当前Boolean对象的值转换为String类型
Boolean temp_B_3 = false;
String string_0 = temp_B_3.toString();
System.out.println("Boolean类型对象temp_B_3的字符串形式为：" + string_0);
System.out.println("------------------------------------");
//6 —— static String toString(boolean s) : 将指定的boolean值转换为String对象
boolean temp_b_4 = true;
String string_1 = Boolean.toString(temp_b_4);
System.out.println("boolean类型变量temp_b_4的字符串形式为：" + string_1);
System.out.println("----------------------------------");
//7 —— static Boolean valueOf(...) : 字符串类型 ——> Boolean类型
Boolean temp_B_4 = Boolean.valueOf("false");
System.out.println("Boolean类型对象temp_B_4的值 = " + temp_B_4);
}
}6.Integer创建机制的面试题（重要）
① Integer.valueOf 的源码在本文的 3.3自动拆装箱 已经提到，这里不作赘述
② 基本数据类型与其对应的包装类用 "==" 比较时，比较的是值是否相等
6.1 练习题1
判断输出结果
public class demo{
public static void main(String[] args){
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i==j);//false，i与j是两个不同的对象
Integer m = 1;//自动装箱，底层调用的是Integer.valueOf(1),从缓冲数组cache中取Integer
Integer n = 1;//自动装箱，底层调用的是Integer.valueOf(1),从缓冲数组cache中取Integer
System.out.println(m==n);//true
Integer x = 128;//自动装箱，底层调用的是Integer.valueOf(128),new一个新的Integer
Integer y = 128;//自动装箱，底层调用的是Integer.valueOf(128),new一个新的Integer
System.out.println(x==y);//false
}
}6.2 练习题2
判断输出结果
public class demo{
public static void main(String[] args){
Integer i1 = 127;//自动装箱，底层调用的是Integer.valueOf(127),从缓冲数组cache中取Integer
Integer i2 = new Integer(127);//new一个新的Integer
System.out.println(i1==i2);//false
Integer i3 = 127;//自动装箱，底层调用的是Integer.valueOf(127),从缓冲数组cache中取Integer
int i4 = 127;
System.out.println(i3==i4);//true，判断的是值是否相等
Integer i5 = 128;//自动装箱，底层调用的是Integer.valueOf(128)，new一个新的Integer
int i6 = 128;
System.out.println(i5==i6);//true,判断的是值是否相等
}
}