奇怪的Java题:为什么128 == 128返回为false,而127 == 127会返回为true?

Java基础

浏览数:118

2019-8-21

AD:资源代下载服务

奇怪的Java题:为什么128 == 128返回为false,而127 == 127会返回为true?

在回答这个问题之前,我们先来看看int和Integer的对比,一步步揭开问题的答案。

1. int与integer的基本使用对比

(1) Integer是int的包装类;int是基本数据类型;

(2) Integer变量必须实例化后才能使用;int变量不需要;

(3) Integer实际是对象的引用,指向此new的Integer对象;int是直接存储数据值 ;

(4) Integer的默认值是null;int的默认值是0。

基本类型(原始数据类型)在传递参数时都是按值传递,而封装类型是按引用传递的(其实“引用也是按值传递的”,传递的是对象的地址)。

由于包装类型都是不可变量,因此没有提供改变它值的方法。

2. int与Integer的深入对比

注:对于引用类型变量,==操作符比较的是两个引用是否指向同一个对象;对于基本类型变量,==操作符比较的是两个变量的值是否相等。

(1) 由于Integer变量实际上是对一个Integer对象的引用,所以两个通过new生成的Integer变量永远是不相等的。

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false

因为new生成的是两个对象,其内存地址不同

image

(2) Integer变量和int变量比较时,只要两个变量的值是相等的,则结果为true。

Integer i = new Integer(100);
int j = 100;
System.out.print(i == j); //true

因为包装类Integer和基本数据类型int比较时,java会自动拆包装为int,然后进行比较,实际上就变为两个int变量的比较

(3) 非new生成的Integer变量和new Integer()生成的变量比较时,结果为false。

Integer i = new Integer(100);
Integer j = 100;
System.out.print(i == j); //false

在JDK 5.0之前,你从未见过Integer j = 100;的表达式,因为类与字面值是不能通用的,除了String。而在JDK 5.0中,这种表达式是可以的!因为编译器成为Integer j = Integer.valueOf(100),后面会有更详细的讲解。

3. Java两种数据类型

3.1 Java两种数据类型分类

原始数据类型,分为boolean、byte、int、char、long

、short、double、float

引用数据类型 ,分为数组、类、接口

3.2 Java为每个原始类型提供了封装类

为了编程的方便还是引入了基本数据类型,但是为了能够将这些基本数据类型当成对象操作,Java为每 一个基本数据类型都引入了对应的包装类型(wrapper class),int的包装类就是Integer,从Java 5开始引入了自动装箱/拆箱机制,使得二者可以相互转换。

原始类型: boolean,char,byte,short,int,long,float,double

封装类类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

4、 基本解析

4.1 自动装箱:将基本数据类型重新转化为对象

public class Test {
    public static void main(String[] args) {
    
        List<Integer>list=new ArrayList();
        //自动把1装箱成Integer包装类
        list.add(1);
    }
}

4.2 自动拆箱:将对象重新转化为基本数据类型

public class Test {
    public static void main(String[] args) {
        //声明一个Integer对象
        Integer num = 9;
        
        //进行计算时隐含的有自动拆箱
        System.out.print(--num);
    }
}

因为对象时不能直接进行运算的,而是要转化为基本数据类型后才能进行加减乘除。

对比:

//装箱Integer num = 10;
//拆箱int num1 = num;

5、深入解析

5.1 情况描述

public class Test {
    public static void main(String[] args) {
        
        // 在-128~127 之内的数
        Integer i = 127;   
        Integer j = 127;
        System.out.println( i==j );   //true
    
        // 在-128~127 之外的数
        Integer m = 128;   
        Integer n = 128;
        System.out.println( m==n );   //false
        
        // 直接在堆中new一个对象
        Integer k = new Integer(100);
    }
}

java在编译Integer x = yyy ;时,会翻译成为Integer x = Integer.valueOf(yyy)。而java API中对Integer类型的valueOf的定义如下,对于-128到127之间的数,会进行缓存,Integer i = 127时,会将127进行缓存,下次再写Integer j = 127时,就会直接从缓存中取,就不会new了。如果超过128就会重新new一个新对象

解析原因: 归结于java对于Integer与int的自动装箱与拆箱的设计,是一种模式:叫享元模式(flyweight)。

  1. 加大对简单数字的重利用,Java定义在自动装箱时对于值从–128到127之间的值,它们被装箱为Integer对象后,会存在内存中被重用,始终只存在一个对象。

2. 而如果超过了从–128到127之间的值,被装箱后的Integer对象并不会被重用,即相当于每次装箱时都新建一个 Integer对象。

image
image

上图也可以从代码断点看出 i 和 j 的地址相同

以上堆,栈,常量池等在java中的概念,可以到 java堆、栈、堆栈,常量池的区别,史上最全总结 学习更多知识。

5.2 Integer源码解析

给一个Integer对象赋一个int值的时候,会调用Integer类的静态方法valueOf,源码如下:

public static Integer valueOf(String s, int radix) throws NumberFormatException {
    return Integer.valueOf(parseInt(s,radix));
}
public static Integer valueOf(int i) {
    
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
        
    return new Integer(i);
}

IntegerCache是Integer的内部类,源码如下:

/**
 * 缓存支持自动装箱的对象标识语义
 * -128和127(含)。
 *
 * 缓存在第一次使用时初始化。 缓存的大小
 * 可以由-XX:AutoBoxCacheMax =选项控制。
 * 在VM初始化期间,java.lang.Integer.IntegerCache.high属性
 * 可以设置并保存在私有系统属性中
 */
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) {
            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);
        }
        high = h;

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

    private IntegerCache() {}
}

陛下…看完奏折,点个赞再走吧!

作者:互扯程序