Java之路：基本数据类型的包装类

在介绍这之前，先说下什么叫做API。

API (Application Programming Interface)就是应用程序编程接口。

假设现在要编写一个机器人程序，去控制一个机器人踢足球，程序需要向机器人发出向前跑、向后转、射门、拦截等命令，没有编过程序的人很难想象如何编写这样的程序。但对于有编程经验的人来说，就知道机器人厂商一定会提供一些控制这些机器人的Java类，该类中就有操纵机器人的各种动作的方法，只需要为每个机器人安排一个该类的实例对象，再调用这个对象的各种方法，机器人就会去执行各种动作。
这个Java类就是机器人厂家提供的应用程序编程的接口，厂家就可以对这些Java类美其名曰：Xxx Robot API（也就是Xxx厂家的机器人API）。好的机器人厂家不仅会提供Java程序用的Robot API，也会提供Windows编程语言（如VC++）用的Robot API，以满足各类编程人员的需要。

基本数据类型的包装类

Java对数据既提供基本数据的简单类型，也提供了相应的包装类。使用基本数据类型，可以改善系统的性能，也能够满足大多数的应用需求。但基本数据类型不具有对象的特性，不能满足某些特殊的需求。

从JDK中可以知道，Java中的很多类的很多方法的参数类型都是Object，即这些方法接收的参数都是对象，同时，又需要用这些方法来处理基本数据类型的数据，这时就要用到包装类。比如，用Integer类来包装整数。

下面来看一个简单的例子：

public class Demo1 {
	public static void main(String[] args) {
		String s = "123";
		int i = Integer.parseInt(s);	// 将字符串转换成整型
		i++;
		System.out.println(i);
	}
}

【结果】

1、装箱与拆箱

所谓装箱，就是把基本类型用它们相对应的引用类型包起来，使它们可以具有对象的特质，例如我们可以把int型包装成Integer类的对象，或者把double包装成Double等。

所谓拆箱，就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化为值类型的数据。

例：

public class Demo1 {
	public static void main(String[] args) {
		Integer x = new Integer(10);	// 装箱
		int temp = x.intValue();	// 拆箱
		System.out.println(temp*temp);
	}
}

【结果】

2、基本数据类型与String的相互转换

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

public class Demo1 {
	public static void main(String[] args) {
		String s1 = "123";
		String s2 = "trueaa";
		String s3 = "true";
		int i = Integer.parseInt(s1);	// 将字符串转换成整型
		i++;
		double d = Double.parseDouble(s1);
		d++;	// 
		boolean b1 = Boolean.parseBoolean(s2);
		boolean b2 = Boolean.parseBoolean(s3);
		System.out.println(i);
		System.out.println(d);
		System.out.println(b1);
		System.out.println(b2);
	}
}

【结果】

在将字符串变为数值型数据时需要注意，字符串的组成必须全部由数字组成。如果此时的字符串内容不是true或false，那么程序也不会出错，会按照false的情况进行处理（如s2）。

将基本数据类型转换为字符串：

public class ToString {
	public static void main(String[] args) {
		int i = 100;
		double d = 120.2;
		boolean b = true;
		char c = 'a';
		// 方法1
		String str = i + "";	// 任何类型与字符串相加之后就是字符串
		System.out.println(str);
		str = d + "";
		System.out.println(str);
		str = b + "";
		System.out.println(str);
		str = c + "";
		System.out.println(str);
		
		// 方法2
		str = String.valueOf(i);
		System.out.println(str);
		str = String.valueOf(d);
		System.out.println(str);
		str = String.valueOf(b);
		System.out.println(str);
		str = String.valueOf(c);
		System.out.println(str);
	}
}

【结果】

注：方法1在将基本数据类型时必须使用一个字符串，所以一定会产生垃圾，不建议使用。

3、Integer类

Integer类的三种创建方式：

public class UseInteger {
	public static void main(String[] args) {
		// 方法1  :  用new关键字
		Integer num1 = new Integer(100);
		// 方法2 : 用Integer类中的valueOf() 
		Integer num2 = Integer.valueOf(200);
		// 方法3 : 自动装箱
		Integer num3 = 300;
		System.out.println("num1 : " + num1);
		System.out.println("num2 : " + num2);
		System.out.println("num3 : " + num3);
	}
}

【结果】

4、Boolean类

java.lang.Boolean类与Integer一样是在对象中封装了一个基本布尔型的值。 Boolean类型的对象包含在一个单一的字段中，其类型为布尔值。与Integer一样Boolean类也有三种生成的方式。
此外Boolean类中还内置了一些实用的方法，如下：

public class CompareBoolean {
	public static void main(String[] args) {
		Boolean b1 = new Boolean(true), 
				b2 = new Boolean(false);
		int result = b1.compareTo(b2);
		String str1 = "Both values are equal";
		String str2 = "Object values is true";
		String str3 = "Argument values is false";
		if(result == 0) {
			System.out.println(str1);
		}
		else if(result > 0) {
			System.out.println(str2);
		}
		else if(result < 0) {
			System.out.println(str3);
		}
	}
}

【结果】

调用compareTo方法对b1、b2进行比较，并将结果赋给res。如果仅b1为真，则res大于零，如果仅b2为真，则res小于零，否则res等于零。

5、Byte类

Byte 类将基本类型 byte 的值包装在一个对象中。一个Byte类型的对象只包含一个类型为 byte 的字段。此外，该类还为byte和String的相互转换提供了几种方法，并提供了处理byte时非常有用的其他一些常量和方法。如下：

public class ByteFun {
	public static void main(String[] args) {
		byte b = 23;
		Byte b1 = new Byte(b),
			 b2 = Byte.valueOf("23"),
			 b3 = 12;
		int x1 = b1.intValue(),
			x2 = b2.intValue(),
			x3 = b3.intValue();
		System.out.println("b1:" + x1 + ", b2:" + x2 + ", b3:" + x3);
		String str1 = Byte.toString(b),
			   str2 = Byte.toString(b2),
			   str3 = b3.toString();
		System.out.println("str1:" + str1 + ", str2:" + str2 + ", str3:" + str3);
		byte bb = Byte.parseByte("23");	// 将String参数解析为有符号的十进制byte
		System.out.println("Byte.parseByte(\"23\"):" + bb);
		boolean bool1 = b1.equals(b2),
			 bool2 = b1.equals(b3);
		System.out.println("b1.equals(b2):" + bool1 + ", b1.equals(b3):" + bool2);
	}
}

【结果】

（1）首先，对于new关键字创建的包装类对象，两次new得到的对象引用地址是不同的，不能使用 “==”关键字做大小比较。而使用“<”和“>”等运算符时，包装类型会调用valueOf方法，将运算符两边的对象都转换为基本类型后再做比较。这就是为何“==”*不能使用而“<”、“>”、“<=”、“>=”这几个符号可以使用的原因。

（2）其次，使用valueOf方法创建的Integer对象，使用“==”符号时，运行结果有时候正确，有时候不正确。查看valueOf方法的源码，如下:

 public static Integer valueOf(int i)
{
	if(i >= -128 && i <= IntegerCache.high)
	return IntegerCache.cache[i+128];
	else
	return new Integer(i);
}

通过看源码能够知道，整数类型在-128～127之间时，会使用缓存，如果已经创建了一个相同的整数，使用valueOf创建第二次时，不会使用new关键字，而用已经缓存的对象。

所以使用valueOf方法创建两次对象，若对应的数值相同，且数值在-128～127之间时，两个对象都指向同一个地址。

最后，使用Integer i = 400这样的方式来创建Integer对象，与valueOf方法的效果是一样的，不再赘述。

总之，包装类对象不可使用“==”符做比较运算，如果要进行比较运算时，最好使用java类库中的compareTo方法。