zoukankan      html  css  js  c++  java
  • Java编程的逻辑 (26)

    包装类

    Java有八种基本类型,每种基本类型都有一个对应的包装类。

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

    Java中,基本类型和对应的包装类如下表所示:

    基本类型 包装类
    boolean Boolean
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    char Character

    包装类也都很好记,除了Integer和Character外,其他类名称与基本类型基本一样,只是首字母大写。

    包装类有什么用呢?Java中很多代码(比如后续文章介绍的集合类)只能操作对象,为了能操作基本类型,需要使用其对应的包装类,另外,包装类提供了很多有用的方法,可以方便对数据的操作。

    包装类的基本使用是比较简单的,但我们不仅会介绍其基本用法,还会介绍一些平时用的相对较少的功能,同时剖析其实现代码,内容比较多,我们会分三节来介绍,本节主要介绍各个包装类的基本用法及其共同点,后两节我们会进一步介绍高级功能,并剖析实现代码。

    让我们逐步来介绍。

    基本类型和包装类

    我们先来看各个基本类型和其包装类是如何转换的,我们直接看代码:

    Boolean

    boolean b1 = false;
    Boolean bObj = Boolean.valueOf(b1);
    boolean b2 = bObj.booleanValue();

    Byte

    byte b1 = 123;
    Byte byteObj = Byte.valueOf(b1);
    byte b2 = byteObj.byteValue();

    Short

    short s1 = 12345;
    Short sObj = Short.valueOf(s1);
    short s2 = sObj.shortValue();

    Integer

    int i1 = 12345;
    Integer iObj = Integer.valueOf(i1);
    int i2 = iObj.intValue();

    Long

    long l1 = 12345;
    Long lObj = Long.valueOf(l1);
    long l2 = lObj.longValue();

    Float

    float f1 = 123.45f;
    Float fObj = Float.valueOf(f1);
    float f2 = fObj.floatValue();

    Double

    double d1 = 123.45;
    Double dObj = Double.valueOf(d1);
    double d2 = dObj.doubleValue(); 

    Character

    char c1 = 'A';
    Character cObj = Character.valueOf(c1);
    char c2 = cObj.charValue(); 

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

    将基本类型转换为包装类的过程,一般称为"装箱",而将包装类型转换为基本类型的过程,则称为"拆箱"。装箱/拆箱写起来比较啰嗦,Java 1.5以后引入了自动装箱和拆箱技术,可以直接将基本类型赋值给引用类型,反之亦可,如下代码所示:

    Integer a = 100;
    int b = a;

    自动装箱/拆箱是Java编译器提供的能力,背后,它会替换为调用对应的valueOf()/xxxValue(),比如说,上面的代码会被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外的其他包装类,都会缓存包装类对象,减少需要创建对象的次数,节省空间,提升性能,后续我们会分析其具体代码。

    重写Object方法

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

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

    我们逐个来看下。

    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。在第5节的时候,我们提到小数计算是不精确的,数学概念上运算结果一样,但计算机运算结果可能不同,比如说,看下面代码:

    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比较。

    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。

    关于equals和hashCode,我们还会在后续的章节中碰到,并进行进一步说明。

    toString

    每个包装类也都重写了toString方法,返回对象的字符串表示,这个一般比较自然,我们就不赘述了。

    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。

    包装类和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)); //输出2进制
    System.out.println(Integer.toHexString(12345)); //输出16进制
    System.out.println(Integer.parseInt("3039", 16)); //按16进制解析

    输出为:

    11000000111001
    3039
    12345

    常用常量

    包装类中除了定义静态方法和实例方法外,还定义了一些静态变量。

    Boolean类型:

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

    所有数值类型都定义了MAX_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;

    Number

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

    复制代码
    byte byteValue()
    short shortValue()                
    int intValue()
    long longValue()
    float floatValue()
    double doubleValue()
    复制代码

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

    不可变性

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

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

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

    小结

    本节介绍了包装类的基本用法,基本类型与包装类的相互转换、自动装箱/拆箱、重写的Object方法、Comparable接口、与String的相互转换、常用常量、Number父类,以及包装类的不可变性。从日常基本使用来说,除了Character外,其他类介绍的内容基本就够用了。

    但Integer和Long中有一些关于位操作的方法,我们还没有介绍,Character中的大部分方法我们也都没介绍,它们的一些实现原理我们也没讨论,让我们在接下来的两节中继续探索。

  • 相关阅读:
    背水一战 Windows 10 (26)
    背水一战 Windows 10 (25)
    背水一战 Windows 10 (24)
    背水一战 Windows 10 (23)
    背水一战 Windows 10 (22)
    背水一战 Windows 10 (21)
    背水一战 Windows 10 (20)
    背水一战 Windows 10 (19)
    背水一战 Windows 10 (18)
    背水一战 Windows 10 (17)
  • 原文地址:https://www.cnblogs.com/ivy-xu/p/12370115.html
Copyright © 2011-2022 走看看