包装类介绍

基本数据类型

---

 

• Java语言提供了八种基本类型：
  • 六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型

• 基本数据类型不具有对象特征，没有属性、方法、无法对象化交互

 
 

包装类

---

 

• 通过包装类，可以让基本数据类型获取对象一样的特征，行使对象的相关权益
• Java中的包装类包括：
  • Integer、Long、Short、Byte、Character、Double、Float、Boolean、BigInteger、BigDecimal
  • 其中 BigInteger、BigDecimal 没有相对应的基本类型，主要应用于高精度的运算
    • BigInteger 支持任意精度的整数
    • BigDecimal 支持任意精度带小数点的运算

 
 

基本数据类型与包装类型的异同

---

 

• 在Java中，一切皆对象，但八大基本类型却不是对象
• 声明方式的不同
  • 基本类型无需通过 new 关键字来创建
  • 包装类型需 new 关键字
• 存储方式及位置不同
  • 基本类型是直接存储变量的值保存在栈中能高效的存取
  • 包装类型需要通过引用指向实例，具体的实例保存在堆中
• 初始值的不同
  • 包装类型的初始值为 null
  • 基本类型的初始值视具体的类型而定，比如 int 类型的初始值为0，boolean 类型为 false
• 使用方式的不同
  • 与集合类合作使用时只能使用包装类型

 
 

包装类常用方法

---

 

• JAVA 是一种面向对象语言，JAVA 中的类把方法与数据连接在一起，构成了自包含式的处理单元
• 在 JAVA 中不能定义基本类型（primitive type）对象，为了能将基本类型视为对象进行处理，并能连接相关的方法，JAVA 为每个基本类型都提供了包装类
• 如：
  • int 型数值的包装类 Integer
  • boolean 型数值的包装类 Boolean 等
• 这样便可以把这些基本类型转换为对象来处理了

---

• Integer
  • Integer 类在对象中包装了一个基本类型 int 的值
  • 该类的对象包含一个 int 类型的字段。
  • 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，同时还提供了处理 int 类型时非常有用的其他一些常量和方法
  • 构造方法：
    • int 型变量作为参数创建 Integer 对象，实例代码如下：
    • Integer number=new Integer(7);
    • 以 String 型变量作为参数创建 Integer 对象，实例代码如下：
    • Integer number=new Integer(“7”);
  • 常用方法：

• 常用的常量：
  • MAX_VALUE: 表示 int 型可取的最大值
  • int maxint = Integer.MAX_VALUE;
  • MIN_VALUE: 表示 int 型可取的最小值
  • int minint = Integer.MIN_VALUE;
  • SIZE：表示以二进制补码形式表示 int 值的位数
  • int intsize = Integer.SIZE;
  • TYPE: 表示基本类型 Class 实例

---

• Boolean
  • Boolean 类将基本类型为 boolean 的值包装在一个对象中
  • 一个 Boolean 类型的对象只包含一个类型为 boolean 的字段
  • 此类还为 boolean 和 String 的相互转换提供了许多方法，并提供了处理 boolean 时非常有用的其他一些常量和方法
  • 构造方法：
    • 创建一个表示 value 参数的 boolean 对象，实例如下：
    • Boolean b = new Boolean(true);
    • String 变量作为参数，创建 boolean 对象。此时，如果传入的字符串不为 null，且忽略大小写后的内容等于”true”,则生成 Boolean 对象值为 true，反之为 false
    • Boolean b1 = new Boolean("ok");
    • System.out.println(b1);
    • Boolean b2=new Boolean("TRUE");
    • System.out.println(b2);
  • 常用方法：

• 常用的常量：
  • TRUE:对应基值 true 的 Boolean 对象
  • FALSR:对应基值 false 的 Boolean 对象
  • TYPE:表示基本类型 Class 实例

---

• Byte
  • Byte 类将基本类型为 byte 的值包装在一个对象中
  • 一个 byte 类型的对象只包含一个类型为 byte 的对象
  • Byte 类提供了两种构造方法的重载形式来创建 BYTE 类对象：
    • Byte(byte value)
    • 通过这种方法创建的 byte 对象，可表示指定的 byte 值
    • 例：
      • byte mybyte=45;
      • Byte b = new Byte(mybyte);
    • Byte(String str)
    • 通过这种方法创建的 byte 对象，可表示 String 参数指定的 byte 值
    • 例：
      • Byte mybyte = new Byte("12")
  • 常用方法：

• 常用的常量：
  • MIN_VALUE: 最小值
  • MAX_VALUE: 最大值
  • SIZE: 二进制
  • TYPE: 表示基本类型 byte 的 class 实例

---

• Character
  • Character 类在对象中包装一个基本类型为 char 的值
  • 一个 Character 对象包含类型为 char 的单个字段
  • 构造方法：
    • Character(char value)
  • 构造方法：

---

• Double/Float
  • Double 和 Float 包装类是对 double、float 基本类型的封装
  • 都是 Number 类的子类，又都是对小数进行操作，所以常用基本方法相同
  • Double 类在对象中包装一个基本类型为 double 的值，每个 double 类都包含一个 double 类型的字段
  • 构造方法：
    • Double（double value):
    • 基于 double 参数创建 Double 类对象
    • Double（String str)
    • 构造一个新分配的 Double 对象，表示用字符串表示的 Double 类型的浮点值
  • 常用方法：

---

• Number
  • 抽象类 Number 是父类
  • Number 的子类必须提供将表示的数值转换成 byte/double/float/long/int/short 的方法
  • Number 类的方法被 Number 的各子类所实现
  • 常用方法：

 
 

基本数据类型和包装类之间的转换

---

 

• 装箱：把基本数据类型转换成包装类
  • 自动装箱
  • 手动装箱
• 拆箱：把包装类转换成基本数据类型
  • 自动拆箱
  • 手动拆箱
• 案例：

public class HelloWorld {
    public static void main(String[] args) {
// 定义int类型变量，值为100
        int score = 100; 
        // 创建Integer包装类对象，表示变量score1的值
        //自动装箱
        Integer score1=score;
        // 将Integer包装类转换为double类型
        double score2=score1.doubleValue();
        // 将Integer包装类转换为long类型
        long score3=score1.longValue();
        // 将Integer包装类转换为int类型
        int score4=score1.intValue();
        //打印输出
        System.out.println("score对应的Integer类型结果为："+score1);
        System.out.println("score对应的double类型结果为："+score2);
        System.out.println("score对应的long类型结果为："+score3);
        System.out.println("score对应的int类型结果为："+score4);
         
    }
}

 
 

基本数据类型和字符串之间的转换

---

 

• 基本数据类型转换为字符串
  • 使用包装类的 toString() 方法
• 字符串转换为基本数据类型
  • 自动拆箱调用包装类的 parseXxx() 静态方法
  • 调用包装类的 valueOf() 方法转换为基本类型的包装类，自动拆箱
• 案例：

public class StringUse {
    public static void main(String[] args) {
        double a = 12.5;
        //将基本类型转换为字符串
        String str1 = Double.toString(a);   
        System.out.println("a 转换为String型后+10的结果为： "+ (str1+10));             
        String str = "2.8";
        // 将字符串转换为基本类型
        //double b = Double.valueOf(str);
        double b = Double.parseDouble(str);
                System.out.println("str 转换为double型后+10的结果为： "+ (b+10)); 
    }
}

 
 

对象常量池

---

 

• 案例：

public class WrapperTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer one=new Integer(100);
		Integer two=new Integer(100);
		System.out.println("one==two的结果："+(one==two));//1
		
		Integer three=100;//自动装箱
		//Integer three=Integer.valueOf(100);
		System.out.println("three==100的结果："+(three==100));//2 自动拆箱
		
		//Integer four=100;
		Integer four=Integer.valueOf(100);
		System.out.println("three==four的结果："+(three==four));//3
		
		Integer five=200;
		System.out.println("five==200的结果："+(five==200));//4
		
		Integer six=200;
		System.out.println("five==six的结果："+(five==six));//5
		
		Double d1=Double.valueOf(100);
		System.out.println("d1==100的结果："+(d1==100));
		
		Double d2=Double.valueOf(100);
		System.out.println("d1==d2的结果："+(d1==d2));
	}

}

• 当方法 valueOf() 在执行的过程中，如果传进来的参数范围大于等于 -128 且小于等于 127 时，会直接从对象池中查找是否存在这样一个对象
  • 如果有这样的一个对象，将会直接产生
  • 如果没有这样的一个对象，将会隐式调用 new 关键字，实例化一个对象
• Java 中八种基本面数据类型及其对应包装类，除了 float 和 double，其他的都可以应用对象常量池概念

 
 

总结案例

---

 

public class HelloWorld {

    public static void main(String[] args) {

        //定义float类型变量，赋值为88.99

		float f1 =88.99f ;

		//将基本类型转换为字符串

		String s=Float.toString(f1)+20;                            

		//打印输出

		System.out.println("f1转换为String型后与整数20的求和结果为："+s);

		//定义String类型变量，赋值为"188.55"

		String str ="188.55";

	    // 将字符串转换为基本类型double

		double d=Double.valueOf(str)+20;             

		//打印输出

		System.out.println("str转换为double型后与整数20的求和结果为："+d);

	}

}