【4】java之基础数据类型的包装类

一、认识包装类

​ java 在设计之初有一个基本原则：一切皆对象，一切的操作都基于对象，但是有一个矛盾，基本数据类型不是对象。为了符合于这种要求，最早使用人为的方式解决此问题，如下所示：

class MyInt{
  private int num; // 这个类包装的基本数据类型
  public MyInt(){}
  public MyInt(int num){ // 构造的目的是将基本数据类型传递给对象，相当于将基本类型进行包装。
    this.num = num;
  }
  public int intValue(){ // 将包装的数据内容返回，相当于拆包。
    return this.num;
  }
}
public class TestDemo{
  public static void main(String args[]){
    MyInt mi = new MyInt(10);
    int temp = mi.intValue()*2;
    System.out.println(temp);
  }
}

​ 在 Java 里为了方便用户的使用，专门提供了一组包装类，来包装所有的基本数据类型： byte（Byte）、short（Short）、int（Integer）、long（Long）、float（Float）、double（Double）、char（Character）、boolean（Boolean）。

以上给出的包装类又分为两种子类型：

• 对象型包装类（Object 直接子类）：Character、Boolean
• 数值型包装类（Number 的直接子类）：Byte、Short、Integer、Long、Float、Double。

Number 是一个抽象类，里面一共定义了6个方法：byteValue()、intValue()、shortValue()、longValue()、floatValue()、doubleValue()。

二、装箱与拆箱

​ 现在已经存在基本数据类型与包装类，那么这两种变量间的转换就通过以下方式定义：

• 装箱操作：将基本数据类型变成包装类，每个包装类的构造方法都可以接收各自数据类型的变量。
• 拆箱操作：从包装类中取出被包装的数据，利用 Number 类中提供的一系列的 xxxValue()方法。

范例：使用 int 和 Integer

public class TestDemo{
  public static void main(String args[]){
    Integer obj = new Integer(50);
    int temp = obj.intValue()*2;
    System.out.println(temp);
  }
}

之前所编写的 MyInt 类，现在换成了 Integer 这个系统类。

范例：使用 double 和 Double。

public class TestDemo{
  public static void main(String args[]){
    Double obj = new Double(50.0);
    double temp = obj.doubleValue();
    System.out.println(temp);
  }
}

范例：使用 boolean 和 Boolean.

public class TestDemo{
  public static void main(String args[]){
    Boolean obj = new Boolean(false);
    boolean temp = obj.booleanValue();
    System.out.println(temp);
  }
}

​ 现在可以发现，所有的包装类都使用了同样形式的方法进行操作。在 JDK 1.5之前能够使用的操作都是以上形式的代码，但是在 JDK 1.5 之后，Java 为了方便开发，提供了自动装箱和拆箱的机制，并且可以直接利用包装类的对象进行数学计算。

范例：自动装箱与自动拆箱

public class TestDemo{
  public static void main(String args[]){
    Integer obj = 10; // 自动装箱
    int temp = obj; // 自动拆箱
	obj ++; // 包装类直接进行数学计算
    System.out.println(temp * obj);
  }
}

范例：

public class TestDemo{
  public static void main(String args[]){
    Boolean flag = true;
    if(flag){
    	System.out.println("Hello World!");
    }
  }
}

如果可以直接使用包装类进行计算，就省略了手工的拆箱部分。

注意：在 Integer 类对象上可以直接赋予内容，也可以使用构造方法，这两者有什么区别呢？

public class TestDemo{
  public static void main(String args[]){
    Integer obja = 10;
	Integer objb = 10;
	Integer objc = new Integer(10);
    System.out.println(obja == objb);    // true
    System.out.println(obja == objc);	 // false
    System.out.println(objb == objc);	 // false
  }
}

​ 在使用包装类的时候很少会利用构造方法完成，几乎都是直接赋值（这一点和 String 相似），但是在判断内容是否相等的时候请一定要用 equals() 方法。

public class TestDemo{
  public static void main(String args[]){
    Integer obja = 10;
	Integer objb = 10;
	Integer objc = new Integer(10);
    System.out.println(obja == objb);
    System.out.println(obja.equals(objc));
    System.out.println(objb.equals(objc));
  }
}

​ 提示： 此时 Object 可以统一天下了。Object 可以接收一切的引用数据类型，但是由于存在有自动装箱机制，那么 Object 可以接收基本数据类型了。

• 基本数据类型 —— 自动装箱（成为对象）—— 向上转型

public class TestDemo{
  public static void main(String args[]){
    Object obj = 10; // 先包装再转换
    int temp = (Integer) obj; // 向下变成 Integer 再自动拆箱
    System.out.println(temp);
  }
}

有了这一系列自动装箱和拆箱的支持后，在数据类型的选择上就方便了许多。

三、数据类型转换（核心）

​ 使用包装类最多的情况实际上是它的数据类型转换功能上，在包装类里提供将 String 类型数据变为基本数据类型的方法，使用几个代表的类来做说明。

• Integer 类：public static int parseInt(String s)；
• Double 类：public static double parseDouble(String s)；
• Boolean类：public static boolean parseBoolean(String s)；

特别需要注意的是 Character 类里并不存在字符串变为字符的方法。因为 String 类有一个charAt()方法可以根据索引取出字符内容。

范例：将字符串变为 int 类型数据。

public class TestDemo{
  public static void main(String args[]){
    String str = "123";
    int temp = Integer.parseInt(str);
    System.out.println(temp*2);
  }
}

此时实现了字符串变为基本数据类型的操作。但是在这样的转换中，字符串一定要由数字组成。

范例：错误的代码

public class TestDemo{
  public static void main(String args[]){
    String str = "hello";
    int temp = Integer.parseInt(str);
    System.out.println(temp*2);
  }
}

范例：观察 double 转换

public class TestDemo{
  public static void main(String args[]){
    String str = "12.3";
    double temp = Double.parseDouble(str);
    System.out.println(temp*2);
  }
}

范例：观察 boolean 转换

public class TestDemo{
  public static void main(String args[]){
    String str = "true";
    boolean flag = Boolean.parseBoolean(str);
    if(flag){
    	System.out.println("true");
    }else{
    	System.out.println("false");
    }
  }
}

在 Boolean 进行转换的过程里，如果要转换的字符不是 true 默认转换结果都是 false。

​ 现在既然实现了字符串变为基本数据类型的操作，那么也一定可以实现基本数据类型变成字符串的操作。有两种做法：

• 操作一：任何基本数据类型与字符串使用了“+”操作后，都表示变成字符串。

public class TestDemo{
  public static void main(String args[]){
  	int temp = 10;
  	String str = temp + "";
  	System.out.println(str);
  }
}

这样的操作虽然可以简单的完成，但是会存在有垃圾问题。

• 操作二：String 类方法 public static String valueOf(数据类型 变量)

public class TestDemo{
  public static void main(String args[]){
  	int temp = 10;
  	String str = String.valueOf(temp);
  	System.out.println(str.replaceAll("0","9"));
  }
}

这样的转换不会产生垃圾，所以在开发时往往使用后者做法。

四、总结

1、JDK 1.5 之后才提供自动装箱和拆箱操作；

2、字符串与基本数据类型的互相转换：

• 字符串变为基本数据类型，依靠包装类的 parseXXX()方法；
• 基本类型变成字符串，依靠 String.valueOf(数据类型 变量)方法。