Java 包装类

Java 包装类,Java有8种基本类型,每种基本类型都有一个对应的包装类。包装类是什么呢?它是一个类,内部有一个实例变量,保存对应的基本类型的值,这个类一般还有一些静态方法、静态变量和实例方法,以方便对数据进行操作。Java中,基本类型和对应的包装类如表所示。
Java 包装类

包装类也都很好记,除了Integer和Character外,其他类名称与基本类型基本一样,只是首字母大写。包装类有什么用呢?Java中很多代码只能操作对象,为了能操作基本类型,需要使用其对应的包装类。另外,包装类提供了很多有用的方法,可以方便对数据的操作。

基本用法

各个包装类都可以与其对应的基本类型相互转换,方法也是类似的,部分类型如表所示。
Java 包装类

包装类与基本类型的转换代码结构是类似的,每种包装类都有一个静态方法valueOf(),接受基本类型,返回引用类型,也都有一个实例方法xxxValue()返回对应的基本类型。

将基本类型转换为包装类的过程,一般称为“装箱”,而将包装类型转换为基本类型的过程,则称为“拆箱”。装箱/拆箱写起来比较烦琐,Java 5以后引入了自动装箱和拆箱技术,可以直接将基本类型赋值给引用类型,反之亦可,比如:

Integer a = 100;
int b = a;

自动装箱/拆箱是Java编译器提供的能力,背后,它会替换为调用对应的valueOf/xxx-Value方法,比如,上面的代码会被Java编译器替换为:

Integer a = Integer.valueOf(100);
int b = a.intValue();

每种包装类也都有构造方法,可以通过new创建,比如:

Integer a = new Integer(100);
Boolean b = new Boolean(true);
Double d = new Double(12.345);
Character c = new Character('马');

那到底应该用静态的valueOf方法,还是使用new呢?一般建议使用valueOf方法。new每次都会创建一个新对象,而除了Float和Double外的其他包装类,都会缓存包装类对象,减少需要创建对象的次数,节省空间,提升性能。实际上,从Java 9开始,这些构造方法已经被标记为过时了,推荐使用静态的valueOf方法。

共同点

各个包装类有很多共同点,比如,都重写了Object中的一些方法,都实现了Comparable接口,都有一些与String有关的方法,大部分都定义了一些静态常量,都是不可变的。下面具体介绍。

1.重写Object方法
所有包装类都重写了Object类的如下方法:

boolean equals(Object obj)
int hashCode()
String toString()

我们分别介绍:
(1)equals
equals用于判断当前对象和参数传入的对象是否相同,Object类的默认实现是比较地址,对于两个变量,只有这两个变量指向同一个对象时,equals才返回true,它和比较运算符(==)的结果是一样的。

equals应该反映的是对象间的逻辑相等关系,所以这个默认实现一般是不合适的,子类需要重写该实现。所有包装类都重写了该实现,实际比较用的是其包装的基本类型值,比如,对于Long类,其equals方法代码如下:

public boolean equals(Object obj) {
    if(obj instanceof Long) {
        return value == ((Long)obj).longValue();
    }
    return false;
}

对于Float,其实现代码如下:

public boolean equals(Object obj) {
    return(obj instanceof Float)
            && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
}

Float有一个静态方法floatToIntBits(),将float的二进制表示看作int。需要注意的是,只有两个float的二进制表示完全一样的时候,equals才会返回true。前面我们提到小数计算是不精确的,数学概念上运算结果一样,但计算机运算结果可能不同,比如下面的代码:

Float f1 = 0.01f;
Float f2 = 0.1f*0.1f;
System.out.println(f1.equals(f2));
System.out.println(Float.floatToIntBits(f1));
System.out.println(Float.floatToIntBits(f2));

输出为:

false
1008981770
1008981771

也就是,两个浮点数不一样,将二进制看作整数也不一样,相差为1。

Double的equals方法与Float类似,它有一个静态方法doubleToLongBits,将double的二进制表示看作long,然后再按long比较。

(2)hashCode
hashCode返回一个对象的哈希值。哈希值是一个int类型的数,由对象中一般不变的属性映射得来,用于快速对对象进行区分、分组等。一个对象的哈希值不能改变,相同对象的哈希值必须一样。不同对象的哈希值一般应不同,但这不是必需的,可以有对象不同但哈希值相同的情况。

比如,对于一个班的学生对象,hashCode可以是学生的出生日期,出生日期是不变的,不同学生生日一般不同,分布比较均匀,个别生日相同的也没关系。

hashCode和equals方法联系密切,对两个对象,如果equals方法返回true,则hashCode也必须一样。反之不要求,equal方法返回false时,hashCode可以一样,也可以不一样,但应该尽量不一样。hashCode的默认实现一般是将对象的内存地址转换为整数,子类如果重写了equals方法,也必须重写hashCode。之所以有这个规定,是因为Java API中很多类依赖于这个行为,尤其是容器中的一些类。
包装类都重写了hashCode,根据包装的基本类型值计算hashCode,对于Byte、Short、Integer、Character, hashCode就是其内部值,代码为:

public int hashCode() {
    return (int)value;
}

对于Boolean, hashCode代码为:

public int hashCode() {
    return value ? 1231 : 1237;
}

根据基类类型值返回了两个不同的数,为什么选这两个值呢?它们是质数(即只能被1和自己整除的数),质数用于哈希时比较好,不容易冲突。
对于Long, hashCode代码为:

public int hashCode() {
    return(int)(value ^ (value >>> 32));
}

是高32位与低32位进行位异或操作。

对于Float, hashCode代码为:

public int hashCode() {
    return floatToIntBits(value);
}

与equals方法类似,将float的二进制表示看作int。

对于Double, hashCode代码为:

public int hashCode() {
    long bits = doubleToLongBits(value);
    return(int)(bits ^ (bits >>> 32));
}

与equals方法类似,将double的二进制表示看作long,然后再按long计算hashCode。
每个包装类也都重写了toString方法,返回对象的字符串表示,这个一般比较自然,不再赘述。

2. Comparable
每个包装类都实现了Java API中的Comparable接口。Comparable接口代码如下:

public interface Comparable<T> {
    public int compareTo(T o);
}

<T>是泛型语法,T表示比较的类型,由实现接口的类传入。接口只有一个方法compareTo,当前对象与参数对象进行比较,在小于、等于、大于参数时,应分别返回-1、0、1。
各个包装类的实现基本都是根据基本类型值进行比较,不再赘述。对于Boolean, false小于true。对于Float和Double,存在和equals方法一样的问题,0.01和0.1*0.1相比的结果并不为0。

3.包装类和String
除了toString方法外,包装类还有一些其他与String相关的方法。除了Character外,每个包装类都有一个静态的valueOf(String)方法,根据字符串表示返回包装类对象,如:

Boolean b = Boolean.valueOf("true");
Float f = Float.valueOf("123.45f");

也都有一个静态的parsexxx(String)方法,根据字符串表示返回基本类型值,如:

boolean b = Boolean.parseBoolean("true");
double d = Double.parseDouble("123.45");

都有一个静态的toString方法,根据基本类型值返回字符串表示,如:

System.out.println(Boolean.toString(true));
System.out.println(Double.toString(123.45));

输出:

true
123.45

对于整数类型,字符串表示除了默认的十进制外,还可以表示为其他进制,如二进制、八进制和十六进制,包装类有静态方法进行相互转换,比如:

System.out.println(Integer.toBinaryString(12345));       //输出二进制
System.out.println(Integer.toHexString(12345));          //输出十六进制
System.out.println(Integer.parseInt("3039", 16));        //按十六进制解析

输出:
Java 包装类

4.常用常量
包装类中除了定义静态方法和实例方法外,还定义了一些静态变量。对于Boolean类型,有:

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

所有数值类型都定义了MAⅩ_VALUE和MIN_VALUE,表示能表示的最大/最小值,比如,对Integer:

public static final int    MIN_VALUE = 0x80000000;
public static final int    MAX_VALUE = 0x7fffffff;

Float和Double还定义了一些特殊数值,比如正无穷、负无穷、非数值,如Double类:

public static final double POSITIVE_INFINITY = 1.0 / 0.0; //正无穷
public static final double NEGATIVE_INFINITY = -1.0 / 0.0; //负无穷
public static final double NaN = 0.0d / 0.0; //非数值

5. Number
6种数值类型包装类有一个共同的父类Number。Number是一个抽象类,它定义了如下方法:

byte byteValue()
short shortValue()
int intValue()
long longValue()
float floatValue()
double doubleValue()

通过这些方法,包装类实例可以返回任意的基本数值类型。

6.不可变性
包装类都是不可变类。所谓不可变是指实例对象一旦创建,就没有办法修改了。这是通过如下方式强制实现的:

  • 所有包装类都声明为了final,不能被继承。
  • 内部基本类型值是私有的,且声明为了final。
  • 没有定义setter方法。

为什么要定义为不可变类呢?不可变使得程序更为简单安全,因为不用操心数据被意外改写的可能,可以安全地共享数据,尤其是在多线程的环境下。

酷客教程相关文章:

赞(0)

评论 抢沙发

评论前必须登录!