前几天看有人贴了一个java代码的问题，实在有意思，今天拿出来和大家分享分享。题目是这样的：给定两个Integer类型的变量a和b，要求实现一个函数swap，交换他们的值。代码如下：
====想一想的分割线 ====
大家用30秒钟想想怎么样实现呢？
====时间到的分割线 ====
估摸着好多盆友一看这个题目，第一反应是：擦，这么简单的题，让我来做，是不是在侮辱我的智商！！！
最简单的实现：
这题目初看一眼，确实好简单，可能只需要10秒钟就可以完成（主要时间花在打字上）：
好了，这就是实现代码，三行！那我们来看看结果：
before : a= 1, b = 2
after : a = 1, b = 2
怎么样，这个结果你猜对了嘛？就是完全没有交换。那是为什么呢？老王画了一张图：
在我们的main函数里，有两个对象变量a和b，他们分别指向堆上的两个Integer对象，地址分别为：0x1234和0x1265，值分别为1和2。在java里，Object a = new Object()这句话执行类似于c++里面的CObj* c = new CObj()，这里a和c实际都是指针（java称做引用），a和c的值，实际是一个内存地址，而不是1、2、3这样的具体的数字。所以，在做swap函数调用的时候，传递的是值，也就是i1得到的a的值：一个内存地址，指向0x1234。同理，i2得到的也是b的值：另外一个内存地址：0x1265。
好了，现在swap入栈，i1、i2、tmp都是指针：
tmp = i1; // tmp得到i1的值：0x1234
i1 =i2; // i1得到i2的值：0x1265
i2 = tmp; // i2得到tmp的值：0x1234
可以看到，在swap里面，i1和i2做了一个指针交换，最后的结果如下：
最终，a和b还是指向对应的内存区域，而这个内存区域的值还是不变。所以，swap这个函数等于啥都没干，完全是浪费表情...
那这个题目似乎看起来就是无解的，对嘛？（谁这么无聊搞一个无解的题目来浪费表情！！！）
换值，解题的曙光：
在准备放弃之前，我们发现了有一个解法似乎可以做：如果把地址0x1234和0x1265中的值1和2对换，a和b的值就变化了，对吧！
那我们就聚焦到用什么方法可以改变这个值呢？
如果Integer提供一个函数，叫做setIntValue(intvalue)，那就万事大吉了。我们可以实现这样的代码：
public
static void swap(Integer i1, Integer i2)
{
// 第二种可能的实现
int tmp = i1.getIntValue()
i1.setIntValue(i2.getIntValue());
i2.setIntValue(tmp);
}
于是，我们就去查阅java.lang.Integer的代码实现。可惜的是，他没有这个函数...我们的梦想、我们的曙光，就这样破灭了...
反射，又燃起新的曙光：
在我们快要绝望的时候，我们突然发现了这个东东：
/**
* The value of the {@code Integer}.
*
* @serial
*/
private
final int
value;
java的Integer实现，实际内部将整数值存放在一个叫int类型的value变量里。他虽然有get函数，但是却没有set函数。因为他是final的（不可修改）！
那怎么办呢？哦，我们差点忘了java里有一个神器：反射！我们可以用反射把取到这个变量，并赋值给他，对吧！
于是，我们写下了如上的代码。我们从Integer类里面，取出value这个属性，然后分别设置上对应的值。哈哈哈，这下总该完美了吧！run一把：
sad... 我们得到了这样的异常：私有的、final的成员是不准我们访问的！
看起来似乎真的没办法了。
老王的绝杀：
这时候，老王从口袋里掏出了以前存起来的绝杀武器：反射访问控制变量：
AccessibleObject.setAccessible(boolean flag)
Field这个类是从AccessibleObject继承下来的，而AccessibleObject提供了一个方法，叫做setAccessible，他能让我们改变对于属性的访问控制。
他会将override变量设置为我们想要的值，然后在Field类里面：
只要这个override的只被设置成true，我们就可以顺利调用set函数啦，于是，我们就简单改一下实现代码：
就只加了这一句话，我们就成功了！哈哈哈哈！！！ 来看结果吧：
before : a= 1, b = 2
after : a = 2, b = 2
等等等等， 好像a已经变了，但是b似乎还没变！ 这是怎么搞的？同样的实现方法，a变了，b没变，完全说不通啊，难道java虚拟机出问题了？这个时候，心里真是一万头草泥马奔过...
看似只差一步，实际还有万里之遥：
那问题到底出在哪儿呢？那我们重头开始看看这段代码。
在函数的一开始，我们就定义了两个变量：Integer a = 1; Integer b = 2; 这里1和2是主类型，换句话说他们是int类型，而a和b是Integer类型。他们是等价的嘛？回答是：NO！！！
装箱
那如果类型不等价，为啥编译的时候不出错呢？这里就要谈到一个java编译器的一个特性：装箱。这个是个什么东东？
按道理说，我们给a赋值的时候，应该是这样写：Integer a =new Integer(1)，这才是标准的写法，对吧。不过这样写多麻烦啊，于是，java编译器给大家做了一个方便的事儿，就是你可以Integera = 1这样写，然后由编译器来帮你把剩下的东西补充完整（java编译器真是可爱，他还有很多其他的糖衣，以后有机会老王专门来介绍）。
那编译器给我们做了什么事情呢？难道是：
a = 1 === 编译 ===> a = new Integer(1) ？
老王最初也认为是这样的，不过后来发现，错了，他做的操作是：
a = 1 === 编译 ===> a = Integer.valueOf(1)
上面这个过程像不像把1这个int类型放入到Integer的箱子里呢？
这是怎么确认的呢？很简单，我们用javap来查看编译后的Swap.class代码即可：
看，我们的main函数第一行，定义Integer a = 1，实际上是做了 Integer a = Integer.valueOf(1)。这个确实是让人出乎意料。那这个函数做了什么事情呢？
这个函数的参数是一个int，然后如果这个int在IntegerCache的low和high之间，就从IntegerCache里面获取，只有超出这个范围，才新建一个Integer类型。
这是IntegerCache的实现，默认在-128和127之间的数，一开始就被新建了，所以他们只有一个实例。老王画了下面的示意图（为了让大家看的清楚，没有画完所有的内存）
我们可以这样来验证：
Integer i1= 1;
Integer i2= 1;
Integer i3= 128;
Integer i4= 128;
System.out.println(i1 == i2);
System.out.println(i3 == i4);
大家猜到答案了么？ 结果是：true， false
因为Integer i1 = 1; 实际是Integer i1 = Integer.valueOf(1)，在cache里，我们找到了1对应的对象地址，然后就直接返回了；同理，i2也是cache里找到后直接返回的。这样，他们就有相同的地址，因而双等号的地址比较就是相同的。i3和i4则不在cache里，因此他们分别新建了两个对象，所以地址不同。
好了，做了这个铺垫以后，我们再回到最初的问题，看看swap函数的实现。
这个函数的入参：i1和i2分别指向a和b对应的内存地址，这个时候，将i1的值（也就是value）传递给int型的tmp，则tmp的值为整数值1，然后我们想把i2的整数值2设置给i1：f.set(i1, i2.intValue()); 这个地方看起来很正常吧？
我们来看看这个函数的原型吧：public
voidset(Object obj, Object value) 他需要的传入参数是两个Object，而我们传入的是什么呢？ Integer的i1，和int的i2.intValue()。对于第一个参数，是完全没问题的；而第二个参数，编译器又给我们做了一次装箱，最终转化出来的代码就像这样：
i1.value =Integer.valueOf(i2.intValue()).intValue();
那我们手动执行一下，
a、i2.intValue() -> 2
b、Integer.valueOf(2) -> 0x1265
c、0x1265.intValue() -> 2
d、i1.value -> 2
所以这个时候，内存里的数据就是这样的了：0x1234被改成2了！！！
接着，我们执行下一句：f.set(i2,tmp); 按照上面的步骤，我们先展开：
i2.value =Integer.valueOf(tmp).intValue();
这里tmp等于1，于是分步执行如下：
a、Integer.valueOf(1) -> 0x1234
b、0x1234.intValue() -> 2
c、i2.value -> 2
注意步骤b的值就是上一步从1改成2的那个值，因此最终内存的值就是：
所以，我们才看到最后a和b输出的都是2。终于终于，我们分析清楚了结果了~~
那要达到最后我们要求的交换，怎么样修改呢？我们有两种方法
1、不要让Integer.valueOf装箱发挥作用，避免使用cache，因此可以这样写：
我们用newInteger代替了Integer.valueOf的自动装箱，这样tmp就分配到了一个不同的地址；
2、我们使用setInt函数代替set函数，这样，需要传入的就是int型，而不是Integer，就不会发生自动装箱
so...问题解决了！
==== 总结的分割线 ====
看看，就是这么简单的一个代码实现，却隐藏了这么不简单的实现，包含了：
1、函数调用的值传递；
2、对象引用的值乃是内存地址；
3、反射的可访问性；
4、java编译器的自动装箱；
5、Integer装箱的对象缓存。
这么好几个隐含的问题。怎么样，你看懂了嘛？
如果觉得老王讲的不错，下周日下午继续关注老王的微信吧（simplemain）