文章目录
6、内置的包装类小结
Java 是一种面向对象的编程语言,Java 中的类把方法与数据类型连接在一起,构成了自包含式的处理单元。但在 Java 中不能定义基本类型对象,为了能将基本类型视为对象处理,并能连接相关方法,Java 为每个基本类型都提供了包装类
,如 int 型数值的包装类 Integer,boolean 型数值的包装类 Boolean 等。这样便可以把这些基本类型转换为对象来处理了。
6.1 所有类的父类Object
Object 是 Java 类库中的一个特殊类,也是所有类的父类。也就是说,Java 允许把任何类型的对象赋给 Object 类型的变量。当一个类被定义后,如果没有指定继承的父类,那么默认父类就是 Object 类。
因此,以下两个类表示的含义是一样的。
public class MyClass{…}
等价于
public class MyClass extends Object {…}
由于 Java 所有的类都是 Object 类的子类,所以任何 Java 对象都可以调用 Object 类的方法
。常见的Object的方法如表 1 所示。
方法 | 说明 |
---|---|
Object clone() | 创建与该对象的类相同的新对象 |
boolean equals(Object) | 比较两对象是否相等 |
void finalize() | 当垃圾回收器确定不存在对该对象的更多引用时,对象垃圾回收器调用该方法 |
Class getClass() | 返回一个对象运行时的实例类 |
int hashCode() | 返回该对象的散列码值 |
void notify() | 激活等待在该对象的监视器上的一个线程 |
void notifyAll() | 激活等待在该对象的监视器上的全部线程 |
String toString() | 返回该对象的字符串表示 |
void wait() | 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待 |
其中,toString()、equals() 方法和 getClass() 方法在 Java 程序中比较常用。
6.1.1 toString() 方法
toString() 方法返回该对象的字符串,当程序输出一个对象或者把某个对象和字符串进行连接运算时,系统会自动调用该对象的 toString() 方法返回该对象的字符串表示。
Object 类的 toString() 方法返回“运行时类名@十六进制哈希码
”格式的字符串,但很多类都重写了 Object 类的 toString() 方法,用于返回可以表述该对象信息的字符串。
哈希码(hashCode),每个 Java 对象都有哈希码属性,哈希码可以用来标识对象,提高对象在集合操作中的执行效率。
先看以下代码:
package 内置包装类的Test;
class Test{
//该类默认继承Object类
}
public class Object_ThreeStaff {
/**
* 需求:演示Object类的三个常用的成员方法
* 1.toString;2。
*/
public static void main(String[]args){
Test test = new Test();//默认构造方法
System.out.println("不加toString:"+test);
System.out.println("加了toString:"+test.toString());
}
}
输出结果为:
以上的程序是随机输出了一些地址信息,从程序的运行结果可以清楚的发现,加和不加 toString() 的最终输出结果是一样的,包名类名@实例对象哈希码
;也就是说对象输出时一定会调用 Object 类中的 toString() 方法打印内容。所以利用此特性就可以通过 toString() 取得一些对象的信息,如下面代码。
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "姓名:" + this.name + ":年龄" + this.age;
}
public static void main(String[] args) {
Person per = new Person("李子", 30);// 实例化Person对象
System.out.println("对象信息:" + per);// 打印对象调用toString()方法
}
}
输出结果为:
对象信息:姓名:李子:年龄30
程序中的 Person 类中重写了 Object 类中的 toString() 方法,这样直接输出对象时调用的是被子类重写过的 toString() 方法。
6.1.2 equals() 方法
在前面学习字符串比较时,曾经介绍过两种比较方法,分别是==运算符
和 equals() 方法
,==运算符是比较两个引用变量是否指向同一个实例,equals() 方法是比较两个对象的内容是否相等
,通常字符串的比较只是关心内容是否相等。
其使用格式如下:
boolean result = obj.equals(Object o);
其中,obj 表示要进行比较的一个对象,o 表示另一个对象。
6.1.3 getClass() 方法
getClass() 方法返回对象所属的类,是一个 Class 对象
。通过 Class 对象可以获取该类的各种信息,包括类名、父类以及它所实现接口的名字等。
例 2
编写一个实例,演示如何对 String 类型调用 getClass() 方法,然后输出其父类及实现的接口信息。具体实现代码如下:
package 内置包装类的Test;
public class Demo类 {
public static void printClassInfo(Object obj) {
// 获取类名
System.out.println("类名:" + obj.getClass().getName());
// 获取父类名
System.out.println("父类:" + obj.getClass().getSuperclass().getName());
System.out.println("实现的接口有:");
// 获取实现的接口并输出
for (int i = 0; i < obj.getClass().getInterfaces().length; i++) {
System.out.println(obj.getClass().getInterfaces()[i]);
}
}
public static void main(String[] args) {
String strObj = new String();
printClassInfo(strObj);//静态方法在类定义时就已经分配内存了,可以直接调用。
}
}
该程序的运行结果如下:
类名:java.lang.String
父类:java.lang.Object
实现的接口有:
interface java.io.Serializable
interface java.lang.Comparable
interface java.lang.CharSequence
6.1.4 object类的应用
上个例子里的pringClassInfo函数的参数可以接收任意引用类型的对象:
既然 Object 类是所有对象的父类,则所有的对象都可以向 Object 进行转换,在这其中也包含了数组和接口类型,即一切的引用数据类型都可以使用 Object 进行接收。
interface A {
public String getInfo();
}
class B implements A {
public String getInfo() {
return "Hello World!!!";
}
}
public class ObjectDemo04 {
public static void main(String[] args) {
// 为接口实例化
A a = new B();
// 对象向上转型
Object obj = a;
// 对象向下转型
A x = (A) obj;
System.out.println(x.getInfo());
}
}
输出结果为:
Hello World!!!
通过以上代码可以发现,虽然接口不能继承一个类,但是依然是 Object 类的子类,因为接口本身是引用数据类型,所以可以进行向上转型操作。
同理,也可以使用 Object 接收一个数组,因为数组本身也是引用数据类型。
public class ObjectDemo05 {
public static void main(String[] args) {
int temp[] = { 1, 3, 5, 7, 9 };
// 使用object接收数组
Object obj = temp;
// 传递数组引用
print(obj);
}
public static void print(Object o) {
// 判断对象的类型
if (o instanceof int[]) {
// 向下转型
int x[] = (int[]) o;
// 循环输出
for (int i = 0; i < x.length; i++) {
System.out.print(x[i] + "\t");
}
}
}
}
输出结果为:
1 3 5 7 9
以上程序使用 Object 接收一个整型数组,因为数组本身属于引用数据类型,所以可以使用 Object 接收数组内容,在输出时通过 instanceof 判断类型是否是一个整型数组,然后进行输出操作。
因为 Object 类可以接收任意的引用数据类型,所以在很多的类库设计上都采用 Object 作为方法的参数,这样操作起来会比较方便。
6.2 Integer类(基本数据包装类基本用法相似)
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类对象包含一个 int 类型的字段。此外,该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,还提供了处理 int 类型时非常有用的其他一些常量和方法。(Float,Double,Byte,Character类用法相似,差异不是很大,就只讲Integer类)
6.2.1 Integer 类的构造方法
Integer 类中的构造方法有以下两个:
Integer(int value):构造一个新分配的 Integer 对象,它表示指定的 int 值。
Integer(String s):构造一个新分配的 Integer 对象,它表示 String 参数所指示的 int 值。
例如,以下代码分别使用以上两个构造方法来获取 Integer 对象:
Integer integer1 = new Integer(100); // 以 int 型变量作为参数创建 Integer 对象
Integer integer2 = new Integer("100"); // 以 String 型变量作为参数创建 Integer 对象
6.2.2 Integer 类的常用方法
在 Integer 类内部包含一些和 int 类型操作有关的方法,表 1 列出了这些常用的方法。
方法 | 返回值 | 功能 |
---|---|---|
byteValue() | byte | 以 byte 类型返回该 Integer 的值 |
shortValue() | short | 以 short 类型返回该 Integer 的值 |
intValue() | int | 以 int 类型返回该 Integer 的值 |
toString() | String | 返回一个表示该 Integer 值的 String 对象 |
equals(Object obj) | boolean | 比较此对象与指定对象是否相等 |
compareTo(Integer,anotherlnteger) | int | 在数字上比较两个 Integer 对象,如相等,则返回 0;如调用对象的数值小于 anotherlnteger 的数值,则返回负值;如调用对象的数值大于 anotherlnteger 的数值,则返回正值 |
valueOf(String s) | Integer | 返回保存指定的 String 值的 Integer 对象 |
parseInt(String s) | int | 将数字字符串转换为 int 数值 |
在实际的编程过程中,经常将字符串转换为 int 类型的数值,或者将 int 类型的数值转换为对应的字符串。以下代码演示如何实现这两种功能:
String str = "456";
int num = Integer.parseInt(str); // 将字符串转换为int类型的数值
int i = 789;
String s = Integer.toString(i); // 将int类型的数值转换为字符串
注意:在实现将字符串转换为 int 类型数值的过程中,如果字符串中包含非数值类型的字符,则程序执行将出现异常。
例 1
编写一个程序,在程序中创建一个 String 类型变量,然后将它转换为二进制、八进制、十进制和十六进制输出。
public class Test03 {
public static void main(String[] args) {
int num = 40;
String str = Integer.toString(num); // 将数字转换成字符串
String str1 = Integer.toBinaryString(num); // 将数字转换成二进制
String str2 = Integer.toHexString(num); // 将数字转换成八进制
String str3 = Integer.toOctalString(num); // 将数字转换成十六进制
System.out.println(str + "的二进制数是:" + str1);
System.out.println(str + "的八进制数是:" + str3);
System.out.println(str + "的十进制数是:" + str);
System.out.println(str + "的十六进制数是:" + str2);
}
}
运行后的输出结果如下:
40的二进制数是:101000
40的八进制数是:50
40的十进制数是:40
40的十六进制数是:28
6.2.3 Integer 类的常量
Integer 类包含以下 4 个常量。
常量名 | 含义 |
---|---|
MAX_VALUE | 值为 231-1 的常量,它表示 int 类型能够表示的最大值。 |
MIN_VALUE | 值为 -231 的常量,它表示 int 类型能够表示的最小值。 |
SIZE | 用来以二进制补码形式表示 int 值的比特位数。 |
TYPE | 表示基本类型 int 的 Class 实例。 |
下面的代码演示了 Integer 类中常量的使用。
int max_value = Integer.MAX_VALUE; // 获取 int 类型可取的最大值
int min_value = Integer.MIN_VALUE; // 获取 int 类型可取的最小值
int size = Integer.SIZE; // 获取 int 类型的二进制位
Class c = Integer.TYPE; // 获取基本类型 int 的 Class 实例
6.3 Number类(抽象类、父类)
Number 是一个抽象类,也是一个超类(即父类)。Number 类属于 java.lang 包,所有的包装类(如 Double、Float、Byte、Short、Integer 以及 Long)都是抽象类 Number 的子类。
Number 类定义了一些抽象方法,以各种不同数字格式返回对象的值。如 xxxValue() 方法,它将 Number 对象转换为 xxx 数据类型的值并返回。这些方法如下表所示:
方法 | 说明 |
---|---|
byte byteValue(); | 返回 byte 类型的值 |
double doubleValue(); | 返回 double 类型的值 |
float floatValue(); | 返回 float 类型的值 |
int intValue(); | 返回 int 类型的值 |
long longValue(); | 返回 long 类型的值 |
short shortValue(); | 返回 short 类型的值 |
我们知道抽象类不能直接实例化,而是必须实例化其具体的子类。如下代码演示了 Number 类的使用:
Number num = new Double(12.5);//使用子类来实例化
System.out.println("返回 double 类型的值:" + num.doubleValue());
System.out.println("返回 int 类型的值:" + num.intValue());
System.out.println("返回 float 类型的值:" + num.floatValue());
执行上述代码,输出结果如下:
返回 double 类型的值:12.5
返回 int 类型的值:12
返回 float 类型的值:12.5
6.4 各种基本数据类型包装类的常用量
6.4.1 Float 类的常用常量
在 Float 类中包含了很多常量,其中较为常用的常量如下。
常量名 | 含义 |
---|---|
MAX_VALUE | 值为 1.4E38 的常量,它表示 float 类型能够表示的最大值。 |
MIN_VALUE | 值为 3.4E-45 的常量,它表示 float 类型能够表示的最小值。 |
MAX_EXPONENT | 有限 float 变量可能具有的最大指数。 |
MIN_EXPONENT | 标准化 float 变量可能具有的最小指数。 |
MIN_NORMAL | 保存 float 类型数值的最小标准值的常量,即 2-126。 |
NaN | 保存 float 类型的非数字值的常量。 |
SIZE | 用来以二进制补码形式表示 float 值的比特位数。 |
TYPE | 表示基本类型 float 的 Class 实例。 |
例子
float max_value = Float.MAX_VALUE; // 获取 float 类型可取的最大值
float min_value = Float.MIN_VALUE; // 获取 float 类型可取的最小值
float min_normal = Float.MIN_NORMAL; // 获取 float 类型可取的最小标准值
float size = Float.SIZE; // 获取 float 类型的二进制位
6.4.2 Double 类的常用常量
在 Double 类中包含了很多常量,其中较为常用的常量如下。
常量名 | 含义 |
---|---|
MAX_VALUE | 值为 1.8E308 的常量,它表示 double 类型的最大正有限值的常量。 |
MIN_VALUE | 值为 4.9E-324 的常量,它表示 double 类型数据能够保持的最小正非零值的常量。 |
NaN | 保存 double 类型的非数字值的常量。 |
NEGATIVE_INFINITY | 保持 double 类型的负无穷大的常量。 |
POSITIVE_INFINITY | 保持 double 类型的正无穷大的常量。 |
SIZE | 用来以二进制补码形式表示 double 值的比特位数。 |
TYPE | 表示基本类型 double 的 Class 实例。 |
6.4.3 Boolean 类的常用常量
在 Boolean 类中包含了很多的常量,其中较为常用的常量如下。
常量名 | 含义 |
---|---|
TRUE | 对应基值 true 的 Boolean 对象。 |
FALSE | 对应基值 false 的 Boolean 对象。 |
TYPE | 表示基本类型 boolean 的 Class 对象。 |
6.4.4 Byte 类的常用常量
在 Byte 类中包含了很多的常量,其中较为常用的常量如下。
常量名 | 含义 |
---|---|
MIN_VALUE | byte 类可取的最小值。 |
MAX_VALUE | byte 类可取的最大值。 |
SIZE | 用于以二进制补码形式表示的 byte 值的位数。 |
TYPE | 表示基本类 byte 的 Class 实例。 |
6.5 System类详解
System 类位于 java.lang 包,代表当前 Java 程序的运行平台,系统级的很多属性和控制方法都放置在该类的内部。由于该类的构造方法是 private 的,所以无法创建该类的对象,也就是无法实例化该类。
System 类提供了一些类变量和类方法,允许直接通过 System 类来调用这些类变量和类方法。
6.5.1 System 类的成员变量
System 类有 3 个静态成员变量,分别是 PrintStream out、InputStream in 和 PrintStream err。
1. PrintStream out
标准输出流。此流已打开并准备接收输出数据。通常,此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。
例如,编写一行输出数据的典型方式是:
System.out.println(data);
其中,println 方法是属于流类 PrintStream 的方法,而不是 System 中的方法。
2. InputStream in
标准输入流。此流已打开并准备提供输入数据。通常,此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
3. PrintStream err
标准的错误输出流。其语法与 System.out 类似,不需要提供参数就可输出错误信息。也可以用来输出用户指定的其他信息,包括变量的值。
例 1
编写一个 Java 程序,使用 System 类实现从键盘输入字符并显示出来。 具体实现代码如下:
import java.io.IOException;
public class Test06 {
public static void main(String[] args) {
System.out.println("请输入字符,按回车键结束输入:");
int c;
try {
c = System.in.read(); // 读取输入的字符
while(c != '\r') { // 判断输入的字符是不是回车
System.out.print((char) c); // 输出字符
c = System.in.read();
}
} catch(IOException e) {
System.out.println(e.toString());
} finally {
System.err.println();
}
}
}
以上代码中,System.in.read() 语句读入一个字符,read() 方法是 InputStream 类拥有的方法。
变量 c 必须用 int 类型而不能用 char 类型,否则会因为丢失精度而导致编译失败。
以上的程序如果输入汉字将不能正常输出。如果要正常输出汉字,需要把 System.in 声明为 InputStreamReader 类型的实例,最终在 try 语句块中的代码为:
InputStreamReader in = new InputStreamReader(System.in, "GB2312");
c = in.read();
while(c != '\r') {
System.out.print((char) c);
c = in.read();
}
如上述代码所示,语句 InputStreamReader in=new InputStreamReader(System.in,“GB2312”) 声明一个新对象 in,它从 Reader 继承而来,此时就可以读入完整的 Unicode 码,显示正常的汉字。
6.5.2 System 类的成员方法
System 类中提供了一些系统级的操作方法,常用的方法有 arraycopy()、currentTimeMillis()、exit()、gc() 和 getProperty()。
1. arraycopy() 方法
该方法的作用是数组复制,即从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束。该方法的具体定义如下:
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
其中,src 表示源数组,srcPos 表示从源数组中复制的起始位置,dest 表示目标数组,destPos 表示要复制到的目标数组的起始位置,length 表示复制的个数。
例 2
下面的示例代码演示了 arraycopy() 方法的使用:
public class System_arrayCopy {
public static void main(String[] args) {
char[] srcArray = {'A','B','C','D'};
char[] destArray = {'E','F','G','H'};
System.arraycopy(srcArray,1,destArray,1,2);
System.out.println("源数组:");
for(int i = 0;i < srcArray.length;i++) {
System.out.println(srcArray[i]);
}
System.out.println("目标数组:");
for(int j = 0;j < destArray.length;j++) {
System.out.println(destArray[j]);
}
}
}
如上述代码,将数组 srcArray 中,从下标 1 开始的数据复制到数组 destArray 从下标 1 开始的位置,总共复制两个。也就是将 srcArray[1] 复制给 destArray[1],将 srcArray[2] 复制给 destArray[2]。这样经过复制之后,数组 srcArray 中的元素不发生变化,而数组 destArray 中的元素将变为 E、B、C、 H,下面为输出结果:
源数组:
A
B
C
D
目标数组:
E
B
C
H
2. currentTimeMillis() 方法
该方法的作用是返回当前的计算机时间,时间的格式为当前计算机时间与 GMT 时间(格林尼治时间)1970 年 1 月 1 日 0 时 0 分 0 秒所差的毫秒数。一般用它来测试程序的执行时间。例如:
long m = System.currentTimeMillis();
上述语句将获得一个长整型的数字,该数字就是以差值表达的当前时间。
例 3
使用 currentTimeMillis() 方法来显示时间不够直观,但是可以很方便地进行时间计算。例如,计算程序运行需要的时间就可以使用如下的代码:
public class System_currentTimeMillis {
public static void main(String[] args) {
long start = System.currentTimeMillis();
for(int i = 0;i < 100000000;i++) {
int temp = 0;
}
long end = System.currentTimeMillis();
long time = end - start;
System.out.println("程序执行时间" + time + "秒");
}
}
上述代码中的变量 time 的值表示代码中 for 循环执行所需要的毫秒数,使用这种方法可以测试不同算法的程序的执行效率高低,也可以用于后期线程控制时的精确延时实现。
3. exit() 方法
该方法的作用是终止当前正在运行的 Java 虚拟机,具体的定义格式如下:
public static void exit(int status)
其中,status 的值为 0 时表示正常退出,非零时表示异常退出。
使用该方法可以在图形界面编程中实现程序的退出功能等。
4. gc() 方法
该方法的作用是请求系统进行垃圾回收,完成内存中的垃圾清除。至于系统是否立刻回收,取决于系统中垃圾回收算法的实现以及系统执行时的情况。定义如下:
public static void gc()
5. getProperty() 方法
该方法的作用是获得系统中属性名为 key 的属性对应的值
,具体的定义如下:
public static String getProperty(String key)
系统中常见的属性名以及属性的说明如表 1 所示。
属性名 | 属性说明 |
---|---|
java.version | Java 运行时环境版本 |
java.home | Java 安装目录 |
os.name | 操作系统的名称 |
os.version | 操作系统的版本 |
user.name | 用户的账户名称 |
user.home | 用户的主目录 |
user.dir | 用户的当前工作目录 |
例 4
下面的示例演示了 getProperty() 方法的使用。
package 内置包装类的Test;
public class GetPro {
public static void main(String[] args) {
String jversion = System.getProperty("java.version");
String oName = System.getProperty("os.name");
String user = System.getProperty("user.name");
String user_dir = System.getProperty("user.dir");
System.out.println("Java 运行时环境版本:"+jversion);
System.out.println("当前操作系统是:"+oName);
System.out.println("当前用户是:"+user);
System.out.println("当前用户的工作目录是:"+user_dir);
}
}