包装类（熟悉）
包装类的概念
通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。
如：
Person p = new Person(); // 是对象
int num = 10; // 从语法层面来说不是对象，违背了我们万物皆对象的理念，故而我们需要像办法将其变成对象，要想创建对象我们就得先要有一个类，故而我们需要将num变量与一个类关联起来。
public class MyInt {
private int num = 10; // 这样我们就无形中将num打包到该类中，然后通过new的方式变成了对象
}
包装类的分类
包装类的主要价值：把我们Java官方的8种基本类型数据的变量通过包装类打包成对象
好处：满足了万物皆对象的理念
包装类（8个） 对应的基本类型（8种）
java.lang.Byte byte 1字节
java.lang.Short short 2字节
java.lang.Integer int 4字节（特殊）
java.lang.Long long 8字节
java.lang.Float float
java.lang.Double double
java.lang.Boolean boolean
java.lang.Character char （特殊）
Integer类的概述和构造方式
-
概念：
- java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。
-
常用的常量
常量类型和名称 功能介绍 public static final int MAX_VALUE 表示int类型可以描述的最大值，即2^31-1（1个符号位，其余全是1故而-1） public static final int MIN_VALUE 表示int类型可以描述的最小值，即-2^31 public static final int SIZE 表示int类型采用二进制补码形式的位数 （4字节 4*8=32位） public static final int BYTES 表示int类型所占的字节个数（4个字节） public static final Class<Integer> TYPE 表示int类型的Class实例(暂时理解为是一种类型的名称即可) -
常用的方法
方法声明 功能介绍 Integer(int value) 根据参数指定的整数来构造对象（已过时） Integer(String s) 根据参数指定的字符串来构造对象 （已过时） int intValue() 获取调用对象中的整数值并返回 static Integer valueOf(int i) 根据参数指定整数值得到Integer类型对象 boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等 String toString() 返回描述调用对象数值的字符串形式 static int parseInt(String s) 将字符串类型转换为int类型并返回 static String toString(int i) 获取参数指定整数的十进制字符串形式 static String toBinaryString(int i) 获取参数指定整数的二进制字符串形式 static String toHexString(int i) 获取参数指定整数的十六进制字符串形式 static String toOctalString(int i) 获取参数指定整数的八进制字符串形式 -
常量、构造方法、常用基本方法的简单应用
package com.huang.task01; /** * @author hhc19 * @date 2022/1/3 15:46 * @description */ public class IntegerTest { public static void main(String[] args) { // 1、打印 Integer；类中常用的常量数值 System.out.println("最大值是：" + Integer.MAX_VALUE); // 2147483647 2^31-1 System.out.println("最小值是：" + Integer.MIN_VALUE); // -2147483648 -2^31 System.out.println("所表示二进制的位数是：" + Integer.SIZE); // 32 System.out.println("所占字节的个数是" + Integer.BYTES); // 4 System.out.println("对应int类型的Class实例（类型名称）是：" + Integer.TYPE); // int System.out.println("--------------------------------------------------"); // 2、使用构造方法构造Integer类型的对象并打印 Integer it1 = new Integer(123); // 从 Java9 开始被valueOf(int i) 所取代（静态工厂方法） // 当字符串和引用变量拼接的时候：自动调用toString方法 System.out.println("it1 = " + it1); // 123 Integer it2 = new Integer("456"); // 从 Java9 开始被parseInt(String) + valueOf(int) 或 value(String) 所取代（都是静态工厂方法） System.out.println("it2 = " + it2); // 456 // 上诉方法已过时，推荐使用Integer类中的静态工厂方法取代之：valueOf(int i),不再需要我们去new对象了，可以直接通过类名.调用 // 相当于从int类型到Integer类型的转换，叫做装箱，也就是打包的过程，相当于发快递 Integer it3 = Integer.valueOf(123); System.out.println("it3 = " + 123); // 123 // 相当于从 String类型到Integer类型的转换 Integer it4 = Integer.valueOf("456"); System.out.println("it4 = " + it4); // 456 Integer it5 = Integer.valueOf(Integer.parseInt("789")); System.out.println("it5 = " + it5); // 789 自动调用toString方法得到的是String类型 // 这就是技术的迭代 // Integer中打包封装的int变量：private final int value; Integer类中的成员变量，它是final的证明一旦初始化不可更改 // 获取调用对象中的整数数值，相当于从Integer类型到int类型的转换, 叫做拆箱，相当于拆快递 int ia = it5.intValue(); // 非静态方法 System.out.println("获取到的整数数据是：" + ia); // 789 得到的是int类型，但是拼接完实际上都会变成String类型 } } -
装箱（基本数据类型到包装类类型的转换）和拆箱（包装类类型到基本数据类型的转换）的概念
- 在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。
- 从Java5开始增加了自动拆箱和自动装箱的功能。
-
自动装箱池：
-
在Integer类的内部提供了自动装箱池技术，将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
Integer类中自动装箱池的源码：--------------------------------------- /** * Cache to support the object identity semantics of autoboxing for values between * -128 and 127 (inclusive) as required by JLS. * * The cache is initialized on first usage. The size of the cache * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option. * During VM initialization, java.lang.Integer.IntegerCache.high property * may be set and saved in the private system properties in the * jdk.internal.misc.VM class. * * * The size of the cache * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option. * 这个说明我们可以通过-XX:AutoBoxCacheMax=<size>来调整装箱池的大小，通过JVM * 这一块涉及到JVM的调优，是我们后面学到的内容。 * 根据我们业务需要可以适当的调整范围，从而提高程序的效率。 */ // 为什么不提供整个int范围内的装箱池？因为没必要，范围太大了消耗内存，我们不一定需要那么大，否则会造成浪费 private static class IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; static { // high value may be configured by property int h = 127; String integerCacheHighPropValue = VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); if (integerCacheHighPropValue != null) { try { int i = parseInt(integerCacheHighPropValue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } catch( NumberFormatException nfe) { // If the property cannot be parsed into an int, ignore it. } } high = h; cache = new Integer[(high - low) + 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); // range [-128, 127] must be interned (JLS7 5.1.7) assert IntegerCache.high >= 127; } private IntegerCache() {} }自动装箱机制代码练习及笔试考点（有关自动装箱池）----------------------------------------- System.out.println("--------------------------------------------------"); // 3、从 Java5 开始增加了自动装箱和自动拆箱的机制 Integer it6 = Integer.valueOf(100); // Java5 之前想要装箱的写法 Integer it7 = 100; // Java5 之后直接通过赋值运算符实现自动装箱 int ib = it7; // Java5 之后直接通过赋值运算符实现自动拆箱，Java5 之前需要使用：Integer对象.intValue();方法 // 装箱随便装，拆箱随便拆。再也不需要调用上方的方法了。 // 自动装箱和自动拆箱的底层机制实际上还是调方法，只不过不需要我自己调了而已。 System.out.println("--------------------------------------------------"); // 4、装箱和拆箱的笔试考点 // 笔试原题是 127 // 自动装箱 Integer it8 = 127; // 128; Integer it9 = 127; // 128; // 手动装箱：以调用构造方法new对象方式 Integer it10 = new Integer(127); // new Integer(128); Integer it11 = new Integer(127); // new Integer(128); // 128 的运行结果： /*System.out.println(it8 == it9); // 比较地址 false 已经装箱成引用类型对象了 System.out.println(it8.equals(it9)); // 比较内容 true 但凡equals方法重写过了就是比较内容 System.out.println(it10 == it11); // 比较地址 false System.out.println(it10.equals(it11)); // 比较内容 true*/ // 127 的运行结果 System.out.println(it8 == it9); // 比较地址 true 127变成true说明地址是一样的（也就是自动装箱池的概念） System.out.println(it8.equals(it9)); // 比较内容 true System.out.println(it10 == it11); // 比较地址 false System.out.println(it10.equals(it11)); // 比较内容 true
-
-
Integer类的其它常用方法（静态方法：提高类名.调用）
// 字符串转整数的静态方法 static int parseInt(String s) 将字符串类型转换为int类型并返回 // 整数转二进制的静态方法：按照不同进制转换 static String toString(int i) 获取参数指定整数的十进制字符串形式 static String toBinaryString(int i) 获取参数指定整数的二进制字符串形式 static String toHexString(int i) 获取参数指定整数的十六进制字符串形式 static String toOctalString(int i) 获取参数指定整数的八进制字符串形式 练习代码------------------------------------------- // 5、实现静态方法的调用 int ic = Integer.parseInt("200"); //200 虽然可以实现字符串转数字，但是得是 纯数字字符串 // int ic = Integer.parseInt("200a"); // 编译ok，运行发生java.lang.NumberFormatException(数字格式异常)，因为有字母 System.out.println("字符串转换为整数的结果是：" + ic); // 200 System.out.println("根据参数指定的整数获取十进制字符串是：" + Integer.toString(ic)); // 200 System.out.println("根据参数指定的整数获取二进制字符串是：" + Integer.toBinaryString(ic)); // 11001000 System.out.println("根据参数指定的整数获取十六进制字符串是：" + Integer.toHexString(ic)); // c8 System.out.println("根据参数指定的整数获取八进制字符串是：" + Integer.toOctalString(ic));// 310
Double类的概念和使用
-
基本概念：
java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法。
-
常用常量
常量类型和名称 功能介绍 public static final int SIZE 表示double类型的二进制位数 public static final int BYTES 表示double类型的字节个数 public static final Class TYPE 表示double类型的Class实例 -
常用的方法
方法声明 功能介绍 Double(double value) 根据参数指定的浮点数据来构造对象（已过时） Double(String s) 根据参数指定的字符串来构造对象 （已过时） double doubleValue() 获取调用对象中的浮点数据并返回 static Double valueOf(double d) 根据参数指定浮点数据得到Double类型对象 boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等 String toString() 返回描述调用对象数值的字符串形式 static double parseDouble(String s) 将字符串类型转换为double类型并返回 boolean isNaN() 判断调用对象的数值是否为非数字 -
代码
package com.huang.task01; /** * @author hhc19 * @date 2022/1/3 18:09 * @description */ public class DoubleTest { public static void main(String[] args) { // 1、打印 Double 类中常用的常量数值 System.out.println("double 类型的二进制位数是：" + Double.SIZE); // 64 System.out.println("double 类型的字节个数是：" + Double.BYTES); // 8 System.out.println("double 类型的Class实例是：" + Double.TYPE); // double System.out.println("-------------------------------------"); // 2、常用方法的使用，还有Java5之前装箱和拆箱方法的实现 Float fl1 = new Float(22.22); // float 类型的数据长度最长是8位,即最多只能显示8位数字 System.out.println("fl1 = " + fl1); // 22.22 // double 向 Double类型进行转换 装箱 Double db1 = new Double(22.22); // double 类型的数据长度最长是16位，最多只能显示16位数字 System.out.println("db1 = " + db1); // 22.22 // String 类型 向 Double 类型进行转换 Double db2 = new Double("22.22"); System.out.println("db2 = " + db2); // 22.22 // Double 类型向 double 类型进行转换 拆箱 double d1 = db2.doubleValue(); System.out.println("d1 = " + d1); // 22.22 System.out.println("-------------------------------------"); // 3、静态工厂方法的使用：即用于替代使用构造方法创建装箱类对象的方法 Double db3 = Double.valueOf(22.22); System.out.println("db3 = " + db3); // 22.22 Double db4 = Double.valueOf("22.22"); System.out.println("db4 = " + db4); // 22.22 Double db5 = Double.valueOf(Double.parseDouble("22.22")); // 先使用parseDouble方法将字符串转换为double System.out.println("db5 = " + db5); // 22.22 System.out.println("-------------------------------------"); // 4、从Java5开始实现自动装箱和自动拆箱 // Double 类里面包装了一个 double 数据类型的变量作为成员变量:private final double value; // Double 类型没有存放自动装箱池 Double db6 = 22.22; double d2 = db6; System.out.println("db6 = " + db6); // 22.22 System.out.println("d2 = " + d2); // 22.22 // Double 类中依旧重写了equals方法和toString方法，即按照内容比较是否相等 System.out.println(db6.equals(d2)); // true System.out.println(db2.toString()); System.out.println("-------------------------------------"); // 5、实现静态方法和成员方法的调用 double d3 = Double.parseDouble("3.14"); System.out.println(d3); // 3,14 // 判断调用对象的数值是否为非数字：是非数字返回true；不是非数字，也就是是数字返回false System.out.println("db2对象的判断结果是：" + db2.isNaN()); // false 不是非数字（是数字） Double db7 = Double.valueOf(0 / 0.0); System.out.println("db7 = " + db7); // NaN System.out.println("db7对象的判断结果是：" + db7.isNaN()); // true 是非数字 } } -
扩展
java.lang.Number类是个抽象类，是上述类的父类，描述的是所有类共有的成员
Number抽象类中有抽象的 intValue()、doubleValue()、longValue()、floatValue()方法，这些方法的抽象类的子类们都需要重写，而底层重写的原理就是 基本数据类型的强制类型转换。
-
Idea中格式化代码的快捷键：ctr + A 选中全部代码，然后 ctr + alt + L 格式化代码
Idea中去除所有空格和留白的快捷键：ctr + A 选中全部代码，然后 ctr + shift + J 去除空白行和空白值，将所有代码缩成一行。
Boolean类的概念和使用
-
基本概念
java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean类型的包装并提供boolean类型到String类之间的转换等方法。
-
常用的常量
常量类型和名称 功能介绍 public static final Boolean FALSE 对应基值为false的对象 public static final Boolean TRUE 对应基值为true的对象 public static final Class TYPE 表示boolean类型的Class实例 -
常用的方法
方法声明 功能介绍 Boolean(boolean value) 根据参数指定的布尔数值来构造对象（已过时） Boolean(String s) 根据参数指定的字符串来构造对象 （已过时） boolean booleanValue() 获取调用对象中的布尔数值并返回 static Boolean valueOf(boolean b) 根据参数指定布尔数值得到Boolean类型对象 boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等 String toString() 返回描述调用对象数值的字符串形式 static boolean parseBoolean(String s) 将字符串类型转换为boolean类型并返回 -
练习代码
package com.huang.task01; /** * @author hhc19 * @date 2022/1/3 20:33 * @description */ public class BooleanTest { public static void main(String[] args) { // 1、打印 Boolean 类中常用的常量数值 System.out.println("Boolean 对应基值为false的对象：" + Boolean.FALSE); // false System.out.println("Boolean 对应基值为true的对象：" + Boolean.TRUE); // true System.out.println("Boolean 类型的Class实例是：" + Boolean.TYPE); // boolean // 2.在Java5之前采用方法进行装箱和拆箱 // 相当于从boolean类型到Boolean类型的转换，装箱 Boolean bo1 = Boolean.valueOf(true); System.out.println("bo1 = " + bo1); // true boolean b1 = bo1.booleanValue(); System.out.println("b1 = " + b1); // true Boolean bo3 = new Boolean(true); System.out.println("bo3 = " + bo3); Boolean bo4 = new Boolean("true"); System.out.println("bo4 = " + bo4); Boolean bo5 = new Boolean("TRUEa"); // 不区分大小写, 但是要求传入的值也必须是忽略大小写之后等于true，否则是false System.out.println("b05 = " + bo5); // Boolean 类中也重写了equals方法和toString方法 // Boolean 类中封装了一个boolean类型的成员变量：private final boolean value; System.out.println("----------------------------------------------"); // 3.从Java5开始支持自动装箱和拆箱 Boolean bo2 = false; boolean b2 = bo2; System.out.println("b2 = " + b2); // false System.out.println("----------------------------------------------"); // 4.实现从String类型到boolean类型的转换 //boolean b3 = Boolean.parseBoolean("112"); // 该方法的执行原理是：只要参数数值不为true或者TRUE时，则结果就是false，查手册和源码 /** * public static boolean parseBoolean(String s) { * return "true".equalsIgnoreCase(s); * } * * 根据源码可以分析出：只要传来的字符串 忽略大小写 之后，等于 true即返回 true，否则返回 false。 */ boolean b3 = Boolean.parseBoolean("TRUE"); System.out.println("b3 = " + b3); // true } }
Character类的概念和使用
-
基本概念
java.lang.Character类型内部包装了一个char类型的变量作为成员变量（private final char value;），主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。
-
常用常量
常量类型和名称 功能介绍 public static final int SIZE 表示char类型的二进制位数 public static final int BYTES 表示char类型的字节个数 public static final Class TYPE 表示char类型的Class实例 -
常用的方法
方法声明 功能介绍 Character(char value) 根据参数指定的字符数据来构造对象（已过时） char charValue() 获取调用对象中的字符数据并返回 static Character valueOf(char c) 根据参数指定字符数据得到Character类型对象 boolean equals(Object obj) 比较调用对象与参数指定的对象是否相等 String toString() 返回描述调用对象数值的字符串形式 static boolean isUpperCase(char ch) 判断参数指定字符是否为 大写 字符 static boolean isLowerCase(char ch) 判断参数指定字符是否为 小写 字符 static boolean isDigit(char ch) 判断参数指定字符是否为 数字 字符 static char toUpperCase(char ch) 将参数指定的字符转换为大写字符 static char toLowerCase(char ch) 将参数指定的字符转换为小写字符 -
练习代码
package com.huang.task01; /** * @author hhc19 * @date 2022/1/3 20:33 * @description */ public class CharacterTest { public static void main(String[] args) { // 1、打印 Character 类中常用的常量数值 System.out.println("Character 类型的二进制位数是：" + Character.SIZE); // 16 System.out.println("Character 类型的字节个数是：" + Character.BYTES); // 2 System.out.println("Character 类型的Class实例是：" + Character.TYPE); // char // Character 也重写了equals方法和 toString方法 // 2.在Java5之前调用方法实现装箱和拆箱机制 // 相当于从char类型到Character类型的转换，装箱 Character ca1 = Character.valueOf('a'); System.out.println("ca1 = " + ca1); // a Character ca3 = new Character('b'); // b // Character ca3 = new Character('box'); // Error: Too many characters in character literal // Character ca4 = new Character("box"); // 类型不匹配 System.out.println("ca3 = " + ca3); // 从Character类型向char类型的转换，拆箱 char c1 = ca1.charValue(); System.out.println("c1 = " + c1); // a System.out.println("----------------------------------------"); // 3.从Java5开始支持自动装箱和拆箱 Character ca2 = 'b'; char c2 = ca2; System.out.println("c2 = " + c2); // b System.out.println("----------------------------------------"); // 4.实现字符类型的判断以及转换 System.out.println(Character.isUpperCase(c2)); // 判断是否为大写字母 false System.out.println(Character.isLowerCase(c2)); // 判断是否为小写字母 true System.out.println(Character.isDigit(c2)); // 判断是否为数字字符 false System.out.println("转换为大写字符是：" + Character.toUpperCase(c2)); // B System.out.println("转换为小写字符是：" + Character.toLowerCase(c2)); // b } }
包装类（Wrapper）的使用总结
-
基本数据类型转换为对应包装类的方式：
- 调用包装类的==构造方法或静态方法（valueOf）==即可
- 获取包装类对象中基本数据类型变量数值的方式：
- 调用包装类中的==xxxValue（非静态）==方法即可
-
字符串转换为基本数据类型的方式：
- 调用包装类中的parseXxx方法即可（char类型没有，因为字符串都是由char组成的）