Integer学习

客官°小女子只卖身不卖艺 2021-09-20 22:16 222阅读 0赞

曾经遇见过一道关于Integer的面试题：

Integer a = 180, b = 180;
    
    Integer c=1,d=1;
    
    System.out.println(a==b);
    
    System.out.println(c==d);

输出为:

false

true

一开始也不明白，后来看了下Integer的源码，才知道Integer默认将-128~127之间的整数存储到了一个数组中，我们使用的时候，直接调用数组中数据，而超过这个范围就会重新创建Integer对象，看下源代码就明白了

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 =
                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 static void swap(Integer a, Integer b) {
        Integer temp = a;
        a = b;
        b = temp;
    }

一开始，我认为应该是传递的引用，调用后，应该会发生数据值的改变，但事实上数据却并没有发生交换。那就继续看代码吧

/**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    @HotSpotIntrinsicCandidate
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    
    /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

看到这里我们也就明白了，我们的数据值保存在value这个私有常量值中，当两个值交换时，因为Integer的自动拆装箱导致传递的是数据值，也就是值传递，因此不会修改原值。想要交换两个Integer对象的值应该通过修改这个value值来实现，因此我们可以通过反射获取这个私有的value属性然后进行修改

private static void swap1(Integer a, Integer b) {
            try {
                Field field = Integer.class.getDeclaredField("value");
                field.setAccessible(true);
                int temp = a.intValue();
                field.set(a, b.intValue());
                field.set(b,temp);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

测试下，发现还是不对，原来field.set()这个方法传入的是对象， field.set(a, b.intValue())这个方法中，b.intValue()相当于Integer.valueOf(a.intValue()).intValue()，而temp只是int，因此并没有修改b中的value值，好，继续改

private static void swap1(Integer a, Integer b) {
            try {
                Field field = Integer.class.getDeclaredField("value");
                field.setAccessible(true);
                Integer temp = Integer.valueOf(a.intValue());
                field.set(a, b.intValue());
                field.set(b,temp);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

我们通过反射机制获取Integer属性值value，然后用a的值重新创建一个对象，这样我们传递的就是一个地址值，从而实现真正的交换

### 注意 ###

以前创建Integer对象的时候，我们都是直接new出来，但是先java已经废弃了这个方法，查看文档发现改为使用Integer.valueOf（）方法，查看valueOf方法我们知道，由于-128~127缓存存在，当我们用第一种方式时每次都会产生一个新的实例，而当你使用静态工厂方法时，不一定会产生一个新的实例，所以这样是现在推荐使用valueOf（）这个方法的原因吧

### 总结 ###

通过这个问题的分析，我们主要涉及到Integer的拆装箱、通过反射机制去修改privat final value、Integer的-128~127的缓存，其他的问题我们以后再研究吧