一道面试题考验了你对java的理解程度

简介

最近有点忙，好久没更新文章了，后面会慢慢恢复...回顾正题

最近看到一篇文章，关于一道面试题，先看一下题目，以下：

public static void main(String[] args) {
        Integer a = 1;
        Integer b = 2;
        System.out.printf("a = %s, b = %s\n", a, b);
        swap(a, b);
        System.out.printf("a = %s, b = %s\n", a, b);
    }

public static void swap(Integer a, Integer b) {
    // TODO 实现
}复制代码

有人可能在没通过仔细考虑的状况下，给出如下的答案

// 特别提醒，这是错误的方式
// 特别提醒，这是错误的方式
// 特别提醒，这是错误的方式
public static void swap(Integer a, Integer b) {
    // TODO 实现
    Integer temp = a;
    a = b;
    b = temp;
}复制代码

很遗憾，这是错误的。重要的事注释三遍

那么为何错误，缘由是什么？

想要搞清楚具体的缘由，在这里你须要搞清楚如下几个概念，若是这个概念搞清楚了，你也不会把上面的实现方法写错

• 形参和实参
• 参数值传递
• 自动装箱

因此，上面的问题先放一边，先看一下这几个概念

形参和实参

什么是形参？什么是实参？概念上的东西，参考教科书或者google去吧，下面直接代码说明更加明显

public void test() {
    int shi_can = 0;

    testA(shi_can);
}

public void testA(int xing_can) {

}复制代码

注：为了清楚的表达意思，我命名的时候并无按照java的驼峰规则命名，这里只是为了演示复制代码

经过上面的代码很清楚的表达形参和实参的概念，在调用testA时，传递的就是实参，而在testA方法签名中的参数为形参

从做用域上看，形参只会在方法内部生效，方法结束后，形参也会被释放掉，因此形参是不会影响方法外的

值传递和引用传递

值传递：传递的是实际值，像基本数据类型
引用传递：将对象的引用做为实参进行传递

java基本类型数据做为参数是值传递，对象类型是引用传递

实参是能够传递给形参的，可是形参却不能影响实参，因此，当进行值传递的状况下，改变的是形参的值，并无改变实参，因此不管是引用传递仍是值传递，只要更改的是形参自己，那么都没法影响到实参的。对于引用传递而言，不一样的引用能够指向相同的地址，经过形参的引用地址，找到了实际对象分配的空间，而后进行更改就会对实参指向的对象产生影响

额，上面表述，可能有点绕，看代码

// 仅仅是一个java对象
public class IntType {

    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}

// main方法
public class IntTypeSwap {
    public static void main(String[] args) {

        // CODE_1
        IntType type1 = new IntType();
        type1.setValue(1);

        IntType type2 = new IntType();
        type2.setValue(2);
      // CODE_1

        swap1(type1, type2);
        System.out.printf("type1.value = %s, type2.value = %s", type1.getValue(), type2.getValue());
        swap2(type1, type2);
        System.out.println();
        System.out.printf("type1.value = %s, type2.value = %s", type1.getValue(), type2.getValue());
    }

    public static void swap2(IntType type1, IntType type2) {
        int temp = type1.getValue();
        type1.setValue(type2.getValue());
        type2.setValue(temp);
    }

    public static void swap1(IntType type1, IntType type2) {
        IntType type = type1;
        type1 = type2;
        type2 = type;
    }
}复制代码

在main方法中，CODE_1中间的代码为声明了两个对象，分别设置value为1和2，而swap1和swap2两个方法的目的是为了交互这两个对象的value值

先思考一下，应该输出的结果是什么
...
...

type1.value = 1, type2.value = 2
type1.value = 2, type2.value = 1复制代码

从输出结果来看swap1并无达到目的，回头看一下swap1

public static void swap1(IntType type1, IntType type2) {
        IntType type = type1;
        type1 = type2;
        type2 = type;
    }复制代码

从值传递的角度来看，对象参数传递采用的是引用传递，那么type1和type2传递过来的是指向对象的引用，在方法内部，直接操做形参，交换了形参的内容，这样形参改变，都是并无对实参产生任何影响，也没有改变对象实际的值，因此，结果是没法交换

而对于swap2，对象引用做为形参传递过来后，并无对形参作任何的改变，而是直接操做了形参所指向的对象实际地址，那这样，不管是实参仍是其余地方，只要是指向该对象的全部的引用地址对应的值都会改变

自动装箱

看我上面的那个例子的swap1，是否是顿时以为与上面的面试题的错误作法很是类似了，是的，错误的缘由是如出一辙的，就是稍微有一点区别，就是Integer不是new出来的，而是自动装箱的一个对象，那么什么是自动装箱呢？jdk到底作了什么事？

若是你不想知道为何，只想知道结果，那么我就直说，自动装箱就是jdk调用了Integer的valueOf(int)的方法，很简单，看源码

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

上面那些若是不想深究能够忽略，就看最后一句，是否是明白了什么呢。没错，也是new出来一个对象，若是想知道上面的代码作了什么处理，能够参考 Long==Long有趣的现象 这篇文章，里面有介绍相似的

好了，有人可能会问，为何会知道自动装箱调用的是valueOf方法，这里其余人怎么知道的我不清楚，我是经过查看反编译的字节码指令知道的

public static void main(String[] args) {
        Integer a = 1;
        Integer b = 2;
        System.out.printf("a = %s, b = %s\n", a, b);
        swap(a, b);
        System.out.printf("a = %s, b = %s\n", a, b);
    }

    public static void swap(Integer a, Integer b) {
        Integer temp = a;
        a = b;
        b = temp;
    }复制代码

反编译出来的结果为

对比一下能够很清楚的看到valueOf(int)方法被调用

回归

好，如今回归正题了，直接操做形参没法改变实际值，而Integer又没有提供set方法，那是否是无解了呢？我很好奇若是有人如下这样写，面试官会有什么反应

public static void swap(Integer a, Integer b) {
        // TODO 实现
        // 无解，
    }复制代码

既然出了确定是有解的，能够实现，回头看看，在上面swap2的那个例子中是经过set方法来改变值的，那么Integer有没有提供呢？答案没有（我没找到）

那就先看看源码

private final int value;
...
public Integer(int value) {
        this.value = value;
    }复制代码

这是Integer的构造函数，能够看到Integer对象实际值是用value属性来存储的，可是这个value是被final修饰的，没办法继续找，value没有提供任何的set方法。既然在万法皆不通的状况下，那就只能动用反射来解决问题

public static void swap(Integer a, Integer b) {
        int temp = a.intValue();
        try {
            Field value = Integer.class.getDeclaredField("value");
            value.setAccessible(true);
            value.set(a, b);
            value.set(b, temp);

        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }复制代码

如今感受很开心，终于找到解决方案，但是当你执行的时候，从输出结果你会发现，jdk在跟我开玩笑吗

a = 1, b = 2
a = 2, b = 2复制代码

为何会出现这种状况，无奈，调试会发现是在value.set的时候将Integer的缓存值改变了，由于value.set(Object v1, Object v2)两个参数都是对象类型，因此temp会进行自动装箱操做，会调用valueOf方法，这样会获取到错误的缓存值，因此，为了不这种状况，就只能不须要调用缓存值，直接new Integer就能够跳过缓存，因此代码改为以下便可

public static void swap(Integer a, Integer b) {
        int temp = a.intValue();
        try {
            Field value = Integer.class.getDeclaredField("value");
            value.setAccessible(true);
            value.set(a, b);
            value.set(b, new Integer(temp));

        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }复制代码

至此，这道题完美结束