java 包装类 万字详解（通俗易懂)
前言
简介和溯源
拆装箱
String类和基本类型的相互转化
String类和包装类型的相互转化
八大包装类的常用方法汇总（含代码演示）
一、前言 :
本节内容是我们《API-常用类》专题的最后一节了。本节内容主要讲包装类， 内容包括但不限于 包装类的诞生 ， 包装类的类图 ， 拆装箱 ， String类和基本类型/包装类型间的相互转化 ，以及 八大包装类常用方法 的演示。up希望能通过IDEA类图，Debug，代码演示等多种方式，帮助大家快速上手并理解java包装类。 注意 : ① 代码中的注释也很重要； ② 不要眼高手低，自己敲一遍才能知道怎么用。 ③ 点击侧边栏目录可以跳转。良工不示人以朴，所有文章都会适时改进。 感谢阅读！
二、简介和溯源
1.简介 :
基本数据类型不是对象，不能使用类的方法；因此， java针对基本类型提供了它们对应的包装类，八大基本数据类型，对应了八种包装类，以对象的形式来调用。包装类有了类的特点，使我们可以调用包装类中的方法。
包装类属于java.base模块，java.lang包下，如下图所示 :
可以看到，在形式上除了Integer和Character这两个包装类外，其他六个包装类的类名均是对应的基本类型首字母大写后得到的。
当然，形式上的东西再咋滴也没有那么重要，那么这些个包装类在类与类的关系上有什么不同呢？下面我们来看看这些个包装类分别是什么来头。
2.溯源 :
IDEA最常用的17个快捷键中， Ctrl + h/H 快捷键可以快速当前类的继承关系，并且在 IDEA中，还可以继而查看当前类继承关系的图表表示。
先来看一下Integer类的继承关系图表 :
可以看到，Integer类继承了Number类，并且实现了若干接口。
现在，利用Ctrl + Alt + b/B 的快捷键，将其他七大包装类分别添加进入该图标，如下GIF所示 :
最后的效果图如下所示 :
哈哈，是不是感觉自己被耍了，这**是什么玩意儿？乱七八糟的! 欸，别急，仔细观察这张图，你只需要记住一个结论：除了Boolean和Character这两个包装类外，其他六大包装类都继承自Number类，并且它们都实现了一些接口。
那么，Boolean类和Character类的类关系图又是个什么情况呢？
Boolean类的类关系图如下 :
Character类的关系图如下 :
可以看到，Boolean类和Character类都没有继承Number类，它们都实现了一些接口，并且实现的接口还不尽相同。当然，你只需要记住Boolean类和Character类与其他六大包装类的区别就行，你也不需要去背它们的关系图，因为背了也没个儿用。
三、装箱和拆箱
1.介绍
装箱 : 基本类型 ——> 包装类型（或者叫对象类型，引用类型)
拆箱 : 包装类型 ——> 基本类型
2.手动拆装箱 :
JDK5.0之前，拆装箱均是手动完成的。
手动装箱，可以使用包装类的构造器来完成，也可以使用 valueOf() 方法。
手动拆箱，以Integer类为例，需要用到 intValue() 方法。
演示 :
以Integer包装类为例，以Intro类为演示类。
代码如下 :
package csdn.knowledge.api.Integer;
public class Intro {
public static void main(String[] args) {
//JDK5.0之前，拆装箱都是手动完成。
int temp = 19;
//手动装箱(基本类型 ————> 包装/引用类型)
Integer integer_0 = new Integer(temp); //划线表示该构造方法已过时
Integer integer_1 = new Integer(11);
Integer integer_2 = Integer.valueOf(temp);
//手动拆箱(包装/引用类型 ————> 基本类型)
int tempI_0 = integer_0.intValue(); /**该方法的接收类型为int类型*/
System.out.println("integer_0的值 = " + integer_0);
System.out.println("integer_1的值 = " + integer_1);
System.out.println("integer_2的值 = " + integer_2);
System.out.println("tempI_0 = " + tempI_0);
System.out.println("----------------------------------");
}
}运行结果 :
3.自动拆装箱 :
JDK5.0开始，java提供了自动拆装箱的机制。（不需要手动调用构造器或者方法了）
自动拆箱 : 实际上 底层仍然调用了valueOf() 方法。
自动装箱 : 实际上 底层仍然调用了intValue() 方法（以Integer包装类为例）
演示 :
以Integer包装类为例，以Intro类为演示类。
代码如下 :
package csdn.knowledge.api.Integer;
public class Intro {
public static void main(String[] args) {
//JDK5.0以后，java提供了自动拆装箱
Integer integer_3 = 199; //（自动）装箱——其实底层调用的仍然是valueOf方法（可Debug）
int tempI_1 = integer_3; //（自动）拆箱——其实底层调用的仍然是intValue方法
System.out.println("integer_3的值 = " + integer_3);
System.out.println("tempI_1 = " + integer_3);
System.out.println("----------------------------------");
}
}运行结果 :
我们可以通过Debug来验证自动拆装箱实际在底层调用了手动拆装箱时用到的方法。如下GIF图 :
可以看到，明明是自动装箱，可我们选择强制跳入方法时，依然跳入了valueOf() 方法；又明明是自动拆箱，可我们选择强制跳入方法时，依然跳入了intValue() 方法。
这里还要再强调一点，关于valueOf() 方法，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对象，而是调用底层的缓冲数组。通过追溯源码，我们可以得知这里的low和high 的实际范围是-128 ~ 127，如下图所示 :
并且，我们依然可以再次通过Debug来看看底层的缓冲数组是否真实存在，如下GIF所示 :
四、关于String类型的转化问题 :
1.String类型和基本类型的相互转化 :
①String类 ——> 基本类型
static 基本类型 parseXxx(String) :
包装类中的该方法可以将字符串类型的数据转换成对应的基本类型，需要用相应的基本类型来作接收。需要注意的是，在将字符串类型转为其他类型前，一定要确认字符串里面的内容能否正常转换，比方说，如果你想把”jdlsajflsajfl“这段字符串转换为int类型，那tm能行吗？这时候IDEA会报数字格式异常，如下图所示 :
演示 :
以Method类为演示类，代码如下 :
package csdn.knowledge.api.Integer;
public class Method {
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);
}
}
运行结果 :
这时候，可能有眼尖的小伙伴儿发现了——这咋没有Character包装类捏？
这是因为在八大包装类中，除了Character类外，其他的7种包装类中都有parseXxx() 方法。如果你想将字符串类型的数据转换成char类型的数据，你可以通过String类中的toCharArray() 方法和 charAt() 方法来做到。还记得我们在String类中讲到的这俩方法吗？
回顾一下 :
转换功能的方法 —— char[] toCharArray() : 将字符串转换成字符数组
获取功能的方法 —— char charAt(int index) : 获取指定索引位置的字符
以StringDemo类为演示类，代码如下 :
package csdn.knowledge.api.Integer;
public class StringDemo {
public static void main(String[] args) {
//定义一个字符串
String string = "CSDN_yyds";
//利用toCharArray() 方法将字符串转换为字符数组
char[] charArray = string.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 = string.charAt(0);
char temp_char_1 = string.charAt(1);
char temp_char_2 = string.charAt(2);
char temp_char_3 = string.charAt(3);
char temp_char_4 = string.charAt(4);
char temp_char_5 = string.charAt(5);
char temp_char_6 = string.charAt(6);
char temp_char_7 = string.charAt(7);
char temp_char_8 = string.charAt(8);
System.out.println("string字符串第一个元素为：" + temp_char_0);
System.out.println("string字符串第二个元素为：" + temp_char_1);
System.out.println("string字符串第三个元素为：" + temp_char_2);
System.out.println("string字符串第四个元素为：" + temp_char_3);
System.out.println("string字符串第五个元素为：" + temp_char_4);
System.out.println("string字符串第六个元素为：" + temp_char_5);
System.out.println("string字符串第七个元素为：" + temp_char_6);
System.out.println("string字符串第八个元素为：" + temp_char_7);
System.out.println("string字符串第九个元素为：" + temp_char_8);
}
}
运行结果:
②基本类型 ——> String类
基本类型要转字符串那就太简单了，最常见的两种方式——①直接与空字符串进行拼接，②String类的valueOf方法。
回顾一下 :
转换功能的方法 —— static String valueOf(...) : 将指定类型数据转换成字符串
演示 :
以StringDemo_1作为演示类，代码如下 :
package csdn.knowledge.api.Integer;
public class StringDemo_1 {
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);
}
}
运行结果 :
2.String类型和包装类的相互转化 :
①String类 ——> 包装类
有两种方式，如下 :
方式一 : Integer integer_0 = Integer.parseInt(字符串类型变量);
方式二 : 利用包装类的构造器，例如 : Integer integer_1 = new Integer(字符串类型变量);
方式一中用到了parseInt方法，注意，我们在上文String类型转基本类型时就用到了parseInt方法，但我们当时是用int类型变量来作接收的。当然，parseInt方法的返回值类型本来就是int类型，如下图所示 :
因此，这里的方式一实际上应用了自动装箱，把等号右边返回的int类型的值，在底层又调用valueOf方法装箱成了Integer包装类。
演示 :
以StringDemo_为演示类，代码如下 :
package csdn.knowledge.api.Integer;
public class StringDemo_ {
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);
}
}
运行结果 :
②包装类 ——> String类
有三种方式，如下 :
方式一 : String xxx = 包装类变量名 + "";
方式二 : String xxx = 包装类类名.toString();
方式三 : String xxx = String.valueOf(...);
方式一和我们上文中提到的基本类型转String类型的方式一回事儿；方式二体现出包装类相对于基本类型的优势，可以直接调用包装类中的方法；方式三也和我们上文中提到的基本类型转String类型的方式一回事儿。因此，这里就不重点演示了，仅以Integer类为例。
以StringDemo_2为演示类，代码如下 :
package csdn.knowledge.api.Integer;
public class StringDemo_2 {
public static void main(String[] args) {
//演示 : 包装类 ————> String类
//方式一 :
Integer integer_0 = 141; //自动装箱
String string_0 = integer_0 + "";
//方式二 :
Integer integer_1 = 135;
String string_1 = Integer.toString(integer_1) + " hello";
//方式三 :
Integer integer_2 = 431;
String string_2 = String.valueOf(integer_2) + " world";
System.out.println("string_0 = " + string_0);
System.out.println("string_1 = " + string_1);
System.out.println("string_2 = " + string_2);
}
}
运行结果 :
五、八大包装类的常用成员方法
0.前言 :
是否还记得我们在开篇中引入的包装类的类图，即下图 :
如果你觉得看这个已经够难受了，那你就错了。IDEA提供了功能，可以将类的方法在类图中直接显示出来。到时候你会头大的，如下GIF所示 :
可以看到，类图的转场效果还是比较nice的。但是，这么多方法，就算up真的要一一演示的话，不说我能不能撑住，我猜你是肯定撑不住。你不信？那好，1h内背完这张图里的所有方法，私信up领取1万块钱（bushi）。所以，up决定把每个包装类中比较典型的几个方法给提出来，再给大家演示演示，咱们都节省时间，你说对不对捏。当然，开个玩笑哈。我们已经学习了API，那么之后如果有用到新的方法直接去API里查看就行，方便地很。
up会在代码中直接标出注释，注明该方法的具体功能以及该方法如何使用。所以，大家结合注释，直接看代码即可。
1.Byte类常用方法汇总 :
以Byte_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Byte_ {
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() : 与方法1同理
double bb1 = b.doubleValue();
System.out.println("double类型变量bb1 = " + bb1);
System.out.println("----------------------------------");
//5 —— int intValue() : 与方法1同理
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);
}
}运行结果 :
2.Short类常用方法汇总 :
以Short_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Short_ {
public static void main(String[] args) {
//演示Short类常用方法
//1 —— 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("------------------------------------");
//1_EX —— int intValue()
//1_EX —— double doubleValue()
//......等等同方法1格式一样的方法。用法原理与方法1相同。
//2 —— 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("------------------------------------");
//3 —— int compareTo(Short anotherShort) : 比较两个Short类对象的值，返回值同方法2
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("------------------------------------");
//4 —— 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("------------------------------------");
//5 —— 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("------------------------------------");
//6 —— 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("----------------------------------");
//7 —— static Short valueOf(...) : 字符串类型 ——> Short类型
Short temp_S_4 = Short.valueOf("1111");
System.out.println("Short类型对象temp_S_4的值 = " + temp_S_4);
}
}
运行结果 :
3.Integer类常用方法汇总 :
以Integer_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Integer_ {
public static void main(String[] args) {
//演示Integer类常用方法
//1 —— int intValue() : 返回当前Integer对象的值，以int基本类型作接收。
Integer temp_I_0 = 1280; //自动装箱
int temp_i_0 = temp_I_0.intValue();
System.out.println("int类型变量temp_i_0 = " + temp_i_0);
System.out.println("------------------------------------");
/*
1_EX —— int intValue()
1_EX —— double doubleValue()
......等等同方法1格式一样的方法。用法原理与方法1相同。
*/
//2 —— 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("------------------------------------");
//3 —— int compareTo(Integer anotherInteger) : 比较两个Integer类对象的值，返回值同方法2
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("------------------------------------");
//4 —— 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("------------------------------------");
//5 —— 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("------------------------------------");
//6 —— 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("----------------------------------");
//7 —— static Integer valueOf(...) : 字符串类型 ——> Integer类型
Integer temp_I_4 = Integer.valueOf("1111");
System.out.println("Integer类型对象temp_I_4的值 = " + temp_I_4);
System.out.println("----------------------------------");
//8 —— 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("----------------------------------");
//9 —— static int sum(int x, int y) : 返回（x + y）的值
System.out.println("100 + 201 = " + Integer.sum(100 ,201));
}
}运行结果:
4.Long类常用方法汇总 :
以Long_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Long_ {
public static void main(String[] args) {
//演示Long类常用方法
//1 —— long longValue() : 返回当前Long对象的值，以long基本类型作接收。
Long temp_L_0 = 2224L; //自动装箱
long temp_l_0 = temp_L_0.longValue();
System.out.println("long类型变量temp_l_0 = " + temp_l_0);
System.out.println("------------------------------------");
/*
1_EX —— int intValue()
1_EX —— double doubleValue()
......等等同方法1格式一样的方法。用法原理与方法1相同。
*/
//2 —— 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("------------------------------------");
//3 —— int compareTo(Long anotherLong) : 比较两个Long类对象的值，返回值同方法2
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("------------------------------------");
//4 —— 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("------------------------------------");
//5 —— 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("------------------------------------");
//6 —— 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("----------------------------------");
//7 —— static Long valueOf(...) : 字符串类型 ——> Long类型
Long temp_L_4 = Long.valueOf("111241");
System.out.println("Long类型对象temp_L_4的值 = " + temp_L_4);
System.out.println("----------------------------------");
//8 —— 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("----------------------------------");
//9 —— static long sum(long x, long y) : 返回（x + y）的值
System.out.println("11111111 + 8888889 = " + Long.sum(11111111 ,8888889));
}
}运行结果 :
5.Character类常用方法汇总 :
以Character_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Character_ {
public static void main(String[] args) {
//演示 : Character类常用方法
//1 —— 装箱拆箱 : valueOf() 和 charValue()
Character character_0 = Character.valueOf('S');
char char_0 = character_0.charValue();
System.out.println("Character类对象character_0的字符是：" + character_0);
System.out.println("char基本类型变量char_0 = " + char_0);
System.out.println("----------------------------------");
//2 —— 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("----------------------------------");
//3 —— int compareTo(Character anotherCharacter) : 比较两个Character类对象的字符，返回值同方法2
Character character_1 = 'a'; //自动装箱
Character character_2 = 'd';
int i2 = character_1.compareTo(character_2);
System.out.println("character_1 - character_2 = " + i2);
System.out.println("----------------------------------");
//4 —— static boolean isDigit(char c1) : 判断该字符是不是数字
//5 —— static boolean isLetter(char c2) : 判断该字符是不是字母
//6 —— static boolean isUpperCase(char c3) : 判断该字符是不是大写形式
//7 —— static boolean isLowerCase(char c4) : 判断该字符是不是小写形式
//8 —— 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("----------------------------------");
//9 —— static char toUpperCase(char c) : 将该字符转换为大写形式，以char类型作接收
//10 —— 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);
}
}
运行结果 :
6.Float类常用方法汇总 :
以Float_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Float_ {
public static void main(String[] args) {
//演示 : Float类常用方法
//1 —— float floatValue() : 返回当前Float对象的值，以float基本类型作接收。
Float temp_F_0 = 1024.11F; //自动装箱
float temp_f_0 = temp_F_0.floatValue();
System.out.println("float类型变量temp_f_0 = " + temp_f_0);
System.out.println("------------------------------------");
/*
1_EX —— int intValue()
1_EX —— double doubleValue()
......等等同方法1格式一样的方法。用法原理与方法1相同。
*/
//2 —— 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("------------------------------------");
//3 —— int compareTo(Float anotherFloat) : 比较两个Float类对象的值，返回值同方法2
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("------------------------------------");
//4 —— 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("------------------------------------");
//5 —— 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("------------------------------------");
//6 —— 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("----------------------------------");
//7 —— 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("----------------------------------");
//8 —— 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("----------------------------------");
//9 —— static float sum(float x, float y) : 返回（x + y）的值
System.out.println("11111.11 + 8889.022 = " + Float.sum(11111.11F,8889.022F));
}
}运行结果 :
7.Double类常用方法汇总 :
以Double_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Double_ {
public static void main(String[] args) {
//演示 : Double类常用方法
//1 —— double doubleValue() : 返回当前Double对象的值，以double基本类型作接收。
Double temp_D_0 = 1024.5; //自动装箱
double temp_d_0 = temp_D_0.doubleValue();
System.out.println("double类型变量temp_d_0 = " + temp_d_0);
System.out.println("------------------------------------");
/*
1_EX —— int intValue()
1_EX —— double doubleValue()
......等等同方法1格式一样的方法。用法原理与方法1相同。
*/
//2 —— static int compare(double x, double y) : 比较两个double变量的值, 如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0。
double temp_d_1 = 888.88;
double temp_d_2 = 888.88;
int i = Double.compare(temp_d_1, temp_d_2);
System.out.println("temp_d_1和temp_d_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i);
System.out.println("------------------------------------");
//3 —— int compareTo(Double anotherDouble) : 比较两个Double类对象的值，返回值同方法2
Double temp_D_1 = 123.1234;
Double temp_D_2 = 1234.123;
int i1 = temp_D_1.compareTo(temp_D_2);
System.out.println("temp_D_1和temp_D_2，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0 : " + i1);
System.out.println("------------------------------------");
//4 —— static double parseDouble(String xxx) : 字符串类型 ——> double基本类型
double temp_d_3 = Double.parseDouble("35252.11125");
System.out.println("double类型变量temp_d_3 = " + temp_d_3);
System.out.println("------------------------------------");
//5 —— String toString() : 将当前Float对象的值转换为String类型
Double temp_D_3 = 3333144217.12;
String string_0 = temp_D_3.toString();
System.out.println("Double类型对象temp_D_3的字符串形式为：" + string_0);
System.out.println("------------------------------------");
//6 —— static String toString(double f) : 将指定的double值转换为String对象
double temp_d_4 = 233.333333333;
String string_1 = Double.toString(temp_d_4);
System.out.println("double类型变量temp_d_4的字符串形式为：" + string_1);
System.out.println("----------------------------------");
//7 —— static double valueOf(...) : 字符串类型 ——> double类型
Double temp_D_4 = Double.valueOf("66666.1235");
System.out.println("Double类型对象temp_D_4的值 = " + temp_D_4);
System.out.println("----------------------------------");
//8 —— static double max(double x, double y) 和 min(double x, double y) : 获取两个数中的最大值和最小值
System.out.println("134.23 和 111.11, 哪个数更大？" + Double.max(134.23, 111.11));
System.out.println("222.111 和 111.222, 哪个数更小？" + Double.min(222.111, 111.222));
System.out.println("----------------------------------");
//9 —— static double sum(double x, double y) : 返回（x + y）的值
System.out.println("11111.11 + 8889.022 = " + Double.sum(11111.11,8889.022));
}
}运行结果 :
8.Boolean类常用方法汇总 :
以Boolean_类为演示类，代码如下 :
package csdn.knowledge.api.Integer.Eight;
public class Boolean_ {
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 int 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 Short valueOf(...) : 字符串类型 ——> Boolean类型
Boolean temp_B_4 = Boolean.valueOf("false");
System.out.println("Boolean类型对象temp_B_4的值 = " + temp_B_4);
}
}运行结果 :
六、包装类总结 :
，以上就是我们包装类的全部内容了。重点在于String类与基本类型/包装类型之间的相互转化。如何进行的转化，使用了什么方法，大家一定要烂熟于心。对于八大包装类的常用方法，虽然说肯定有遗漏的，没有举出例子的方法，而且up也并没有把各个方法的源码放出来，给大家仔细讲解源码。但是毕竟是基础阶段，委实不适合如此干。当然up自己是看过源码才知道这些个方法是咋用的，大家如果有兴趣，也很简单，直接Ctrl + b/B 追进去看看，或者Debug一下就懂了。至于这些个方法的用法，我觉得已经标注的挺清楚了。 感谢阅读！
System.out.println("END--------------------------------------------------");