Integer类型和int类型相等的值是否相等? - Java

原创

ClearlightY 2022-11-04 18:08:58 博主文章分类：Java基础知识 ©著作权

文章标签 Integerl类型 valueOf java == 基本数据类型 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者ClearlightY的原创作品，请联系作者获取转载授权，否则将追究法律责任

文章目录

概要
问题描述
问题分析
扩展equals(Object obj)比较
代码演示
代码反编译

概要

java当中,对于"=="符号肯定不陌生,总的来讲:==比较的是值是否相等
相关文章:Java中==与equals()方法的区别

基本数据类型:数值大小是否相等
引用数据类型:对象的引用地址的值是否相等

可是,
int i0 = 59;
Integer i1 = new Integer(59);
i0 == i1 ; 是否相等呢?
第一感觉肯定认为是false;可是经测试结果为true.
这时候肯定是有点懵,一个基本数据类型和一个引用数据类型比较怎么可能是true呢?

问题描述

对于不明白的等式,点击即可跳转到解析(手机端不支持锚点的跳转)

int i0 = 59;
Integer i1 = 59;
Integer i2 = new Integer(59);
Integer i3 = new Integer(59);
Integer i4 = Integer.valueOf(59);

i0 == i1: true i0 == i2: true
i1 == i2: false
i2 == i3: false
i0 == i4: true
i1 == i4: true
i2 == i4: false

Integer i5 = 128;
Integer i6 = Integer.valueOf(128);
i5 == i6 false
以上为输出结果,代码请看文章末尾,代码演示

问题分析

疑惑点1:i0为何与i1,i2,i3,i4都相等?

通过反编译工具,就可以很容易的理解为何会相等.
int i0 = 59;
Integer i2 = new Integer(59);
源码:　　System.out.println("i0 == i2: " + (i0 == i2));
反编译后:System.out.println((new StringBuilder("i0 == i2: ")).append(i0 == i2.intValue()).toString());

看标记的两个位置的区别，Integer包装类型在和基本数据类型比较时,jvm会自动把包装数据类型拆箱为基本数据类型int

Integer.intValue()源码

/**
     * Returns the value of this {@code Integer} as an
     * {@code int}.
     */
    public int intValue() {
        return value;
    }

疑惑点2: i1和i4为何相等?

Integer i1 = 59;
Integer i4 = Integer.valueOf(59);

首先需要了解,Integer i1 = 59;是如何赋值的?
同样,通过反编译工具可以了解.
反编译后为: Integer i1 = Integer.valueOf(59); 所以形式上 i1和i4相等.
现在就需要深入了解一下Integer.valueOf(int i)的方法原理

Integer.valueOf(int i) 源码

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

其中IntegerCache中的变量low为-128,high为127.
首先判断 i 是否在IntegerCache类的范围内,不在的话,就需要重新开辟一个内存空间来存储Integer对象.

现在可以判断的是,如果 i 不在范围内,那么Integer.valueOf(i)自身比较或者与new Integer比较都不会相等,因为存储对象的内存地址的值不同,所以一定不会相等.

可是, i 如果在范围内是如何存储的呢?继续深入来分析IntegerCache类的源码.

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() {}
    }

如果 i 在Integer.valueOf(int i) 的范围内,则返回 IntegerCache.cache[i + (-IntegerCache.low)];
假设传入的值为100, 那么将返回 cache[228].
那么cache[228]存储的是100么?
看上面源码.
static final Integer cache[]; ...(省略中间源码) cache = new Integer[(high - low) + 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++);
首先声明一个Integer类型的数组,之后开辟一个数组大小为(127-(-128)+1)即256的空间.(其实就是[-128,127]之间的数量大小).后面开始赋值.
cache[0] = -128, case[1] = -127, … … cache[228] = 100, … cach[256] = 127.

因此返回cache[228],即100.
源码为啥那样写呢?咱也不知道,咱也不敢问.

分析完成后,应该理解了吧. Integer i1 = 59 或者 Integer i4 = Integer.valueOf(59).这两种方式进行赋值,只要在[-128,127]范围内, 最后进行 "=="比较肯定是相等的.
IntegerCache类已经开辟了[-128,127]的数组空间,所以比较时,两者的内存地址相同,故最后相等.

扩展 :

Integer类型和int类型相等的值是否相等? - Java_==

Integer类型和int类型相等的值是否相等? - Java_基本数据类型_02

图片来源 : Java中整型的缓存机制

注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
　　　　　Double、Float的valueOf方法的实现是类似的。
　　　　　两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。

疑惑点?还有疑惑点么?

我相信你把上面两个疑惑搞懂之后,在回头看估计不成问题了.其他的几个除了和基本类型的比较之外,剩下的都是对象的内存地址的值是否相等了,如果为false,那么肯定是两个对象的内存地址的值不相等喽.

在有不懂的欢迎留言评论

扩展equals(Object obj)比较

Integer类重写了父类的equals方法.

源码
public boolean equals(Object obj) { if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false; }

可以看出equals比较的是两个对象的值是否相等.

2019.6.8补充
问题

int a = 1;
        Integer integer = new Integer(1);
        System.out.println(integer.equals(a)); // 输出结果:true

为什么会是true呢?
解答
反编译后,看到将基本数据类型a装箱,再看Integer类中重写的equals()方法

int a = 1;
    Integer integer = new Integer(1);
    System.out.println(integer.equals(Integer.valueOf(a)));

Integer类中equals(Object obj)方法

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

编译阶段将基本类型a自动装箱为Integer类型,然后再比较两者的值是否相等.

代码演示

public class Integer_int_比较 {
  public static void main(String[] args) {
    int i0 = 59;
    Integer i1 = 59;
    
    System.out.println("int i0 = 59;\nInteger i1 = 59;\nInteger i2 = new Integer(59);\nInteger i3 = new Integer(59);\nInteger i4 = Integer.valueOf(59);");
    
    System.out.println("i0 == i1: " + (i0 == i1));
    
    Integer i2 = new Integer(59);
    
    System.out.println("i0 == i2: " + (i0 == i2));
    System.out.println("i1 == i2: " + (i1 == i2));
    
    Integer i3 = new Integer(59);
    
    System.out.println("i2 == i3: " + (i2 == i3));
    
    Integer i4 = Integer.valueOf(59);
    
    System.out.println("i0 == i4: " + (i0 == i4));
    System.out.println("i1 == i4: " + (i1 == i4));
    System.out.println("i2 == i4: " + (i2 == i4));
    
    Integer i5 = 128;
    Integer i6 = Integer.valueOf(128);
    System.out.println("Integer i5 = 128;\r\nInteger i6 = Integer.valueOf(128);");
    System.out.println("i5 == i6 " + (i5 == i6));
  }
}

代码反编译

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   Integer_int_6BD48F83.java

package cn.com.clearlight.demo;

import java.io.PrintStream;

public class Integer_int_6BD48F83
{

  public Integer_int_6BD48F83()
  {
  }

  public static void main(String args[])
  {
    int i0 = 59;
    Integer i1 = Integer.valueOf(59);
    
    System.out.println("int i0 = 59;\nInteger i1 = 59;\nInteger i2 = new Integer(59);\nInteger i3 = new Integer(59);\nInteger i4 = Integer.valueOf(59);");
    
    System.out.println((new StringBuilder("i0 == i1: ")).append(i0 == i1.intValue()).toString());
    
    Integer i2 = new Integer(59);
    
    System.out.println((new StringBuilder("i0 == i2: ")).append(i0 == i2.intValue()).toString());
    System.out.println((new StringBuilder("i1 == i2: ")).append(i1 == i2).toString());
    
    Integer i3 = new Integer(59);
    
    System.out.println((new StringBuilder("i2 == i3: ")).append(i2 == i3).toString());
    
    Integer i4 = Integer.valueOf(59);
    
    System.out.println((new StringBuilder("i0 == i4: ")).append(i0 == i4.intValue()).toString());
    System.out.println((new StringBuilder("i1 == i4: ")).append(i1 == i4).toString());
    System.out.println((new StringBuilder("i2 == i4: ")).append(i2 == i4).toString());
    
    Integer i5 = Integer.valueOf(128);
    Integer i6 = Integer.valueOf(128);
    
    System.out.println("Integer i5 = 128;\r\nInteger i6 = Integer.valueOf(128);");
    System.out.println((new StringBuilder("i5 == i6 ")).append(i5 == i6).toString());
  }
}