发布于 2年前

Java 数值相等判断详解(特别注意包装类型之间的比较)

Java数值类型分为基本类型,包装类型。

  • 基本类型:byte、short、 int、long、float和double
  • 包装类型:Byte、Short、Integer、Long、Float和Double

数值比较可分为基本类型之间比较,基本类型与包装类类型比较,包装类型之间的比较。

基本类型比较

基本类型之间只能使用“==”做相等比较。比较结果就是数值是否相等。

int a=1, b=1,c=2;
System.out.println(a==b);  //输出true
System.out.println(a==c);  //输出false

基本类型与包装类型比较

包装类型可使用“==”和.equals()方法与基本类型的数字比较。

  • ==:使用==比较,包装类型对象会先拆箱(转为基本类型)后再和基本类型比较,比较结果为数值是否相等。
  • .equals(): 包装类型的.equals()方法比较包装的数值是否相等。
Integer a=1, b=1,c=2;
System.out.println(a==b);  //输出true
System.out.println(a==c);  //输出false

基本类型与包装类型的这两种方式都是比较数值,结果符合比较预期。

整型包装类型比较

包装类型的整型和浮点型它们各自的比较有一点差别,分开说明。

包装类型比较方式有==和equals()方法。

==比较:

以Integer为示例:

Integer a1 = 127, b1 = 127;
Integer a2 = 128, b2 = 128;
Integer a3 = new Integer(127), b3= new Integer(127);

System.out.println(a1 == b1);  //输出为true
System.out.println(a2 == b2);  //输出为false
System.out.println(a3 == b3);  //输出为false

示例中,同样是数值比较,a1和b1比较结果为true,而a2和b2比较结果却为false。两者之间的差别只有数值不同。a3和b3比较结果为false,虽然它们的数值都是127,与a1和b1不同的地方是,a3和b3是通过构造函数赋值。

Java出于性能考虑会在内存里构造一些常量池,这种做法叫做享元模式。在整型包装类型里用了这种方式,数值缓存在Integer内部类IntegerCache里,代码如下:

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

在IntegerCache的代码可以看出,缓存的的范围默认为[-128,127]。你也可以使用java.lang.Integer.IntegerCache.high属性来设置缓存的最大值,但最大值不能超过(Integer.MAX_VALUE - 129)。

在看下构造Integer对象的两种主要方法:

public Integer(int value) {
    this.value = value;
}

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

第一种是通过Integer构造函数来构造对象, 第二种是使用valueOf(int i)方法。

从valueOf(int i)代码可以看到,当参数i值在IntegerCache指定的范围内时,共享使用IntegerCache缓存的Integer对象。超出它的范围则直接构造Integer对象。

首先要知道,引用类型的对象的==比较是判断两个对象的内存地址是否一样,相同则为true。包装类型是引用类型的一种。

示例里比较解释如下:

  1. a1==b1:数值赋值,数值在[-128,127]范围内,a1和b1实际对象为IntegerCache缓存对象,对象地址相同,结果为true。
  2. a2==b2:数值赋值,数值超出[-128,127]范围,a2和b2为新构建对象,对象对应的内存地址不相同,结果为false。
  3. a3==b3:新构建对象,尽管数值相同,但对象内存地址不同,结果为false。

equals()比较:

equals()方法比较的是数值,数值相等则为true;上面的例子

System.out.println(a1.equals(b1));   //true
System.out.println(a2.equals(b2));   //true
System.out.println(a3.equals(b3));   //true

浮点包装类型比较

和其他引用类型比较一样。==比较的是包装类型对象的内存地址。而浮点包装类型equals()方法比较的是数值。

用法小结

包装类型的==实际比较的是对象的内存地址是否相同,equals()方法比较的是数值是否相等。

用法如下:

  1. 基本类型之间使用==作为相等判断,
  2. 基本类型和包装类型使用==或使用包装类型的equals()方法做相等判断
  3. 包装类型之间使用equals()方法做相等判断
©2020 edoou.com   京ICP备16001874号-3