算法细节系列（1）：Java swap
问题
在C++中，swap算法可以用指针来实现，因此在Java中，如果采用如下代码来对两个数字进行交换时，也不会影响两个对象的值。
public class TestSwap {
public static void main(String[] args) {
int a =2;
int b =3;
System.out.println("交换前 -> "+a+":"+b);
swap(a, b);
System.out.println("交换后 -> "+a+":"+b);
}
public static void swap(int a,int b){
int temp =a;
a = b;
b = temp;
}
}console输出结果为：
交换前 -> 2:3
交换后 -> 2:3原因
在Java中，对基本类型的操作都是传值操作，在进入swap语句中时，我把a的值传给了新的变量a，而非原先的变量a。这在C++中，也是一个道理。但你又问了，Java不是实现了引用嘛，看如下代码
/**引用传递**/
StringBuffer sb = new StringBuffer("Hello");
addStr(sb);
System.out.println(sb);
public static void addStr(StringBuffer sb){
sb.append(",my name is demon!");
}console输出结果为：
Hello,my name is demon!StringBuffer是Java中的类，定义了一个addStr()方法，并把sb对象，传入到方法中去，并且成功的改变了sb的值，这就说明进入方法体后，方法体中的局部变量sb指向了存放“Hello”的对象内存去了，不管这个指向是引用还是指针，起码引用传递能够改变原先变量sb的值嘛。
没错，但在Java中，对类有两类划分，一类为基本类型，即我们见到的int,char,byte….等等这些小写开头的基本数据类型，还有一类在Java类库中都是以class关键字定义的类型，该类型为引用类型，即只有这些以class定义的类型才能够真正实现引用传递，而基本类型传递的只是参数值而已。
于是我便突发奇想，嗯，在《Thinking in Java》中提到，每个基本类型都有对应的包装类，即Int ->Integer char -> Character，包装类都是用class定义的引用类型，于是咱们来试试对包装类的参数传递是什么结果？
Integer integerA = new Integer(2);
Integer integerB = new Integer(3);
System.out.println("交换前 -> "+integerA+":"+integerB);
swap(integerA, integerB);
System.out.println("交换前 -> "+integerA+":"+integerB);
public static void swap(Integer a,Integer b){
Integer temp =a;
a = b;
b = temp;
}console输出结果：
交换前 -> 2:3
交换前 -> 2:3大失所望，怎么回事啊，包装类不是引用类型嘛，为何依旧无法实现swap的正确传值？思考了很久，结合自己封装的包装类是如何实现swap的，得出了比较合理的解释，其实引用本身是对一个类的别名！它不像C++中的指针那样，如果指针指向某个内存单元，对它赋值就能直接改变内存单元的值，对内存单元的操作，直接由指针指向来完成。在Java中，上述版本的swap方法，显然并没有对引用指向的内存单元进行操作，而只是改变了引用的指向。
进入swap方法体后，a = integerA,b =integerB,引用a和引用b，copy了实际变量integerA和integerB，也就是说，虽然方法体内完成了对引用的交换，但a和b分别为躺在内存中的实际数据2和3的另外一个指向罢了。方法体中完成了交换，却不影响integerA和integerB的指向。那跟基本类型的值传递有何区别，基本类型的传递是拷贝内存单元的实际数据，即内存单元中存在两份一模一样的数据，分别由变量a和方法体内的a表示，而引用传递，在内存单元中只存放了一份实际数据，只是变量integerA和方法体内的a均指向该内存单元。
而明显的，只有当方法体中的a对包装类的值进行改变时，才能够影响integerA中内存单元的值。而如果只是简单的对引用进行操作，那么即使是包装类也无法产生效果，从sb中也可以看出，它append了”my name is demon.”这就是对指向该内存单元的数据做了改变，由此改变了原先sb的值。
因此，我们得出一个解决方案，封装自己的包装类，实现引用传递，并且在引用传递的过程中，要改变实际内存单元的值。所以在包装类中我们需要有一个改变类中基本类型的方法。这也就解释了为什么Integer无法实现swap的原因了，不变类中的基本类型是final类型的，即它只允许初始化一次，后续是不能被改变的，否则就不符合int基本类型的性质，且你在Integer官方提供的方法中也无法找到改变初始值的方法。
自己实现的MyInteger实现数据交换：
public class MyInteger {
private int num;
public MyInteger(int num){
this.num = num;
}
public int getNum() {
return this.num;
}
public void setNum(int num){
this.num = num;
}
@Override
public String toString() {
return num+"";
}
}
/**引用传递+改变内存单元**/
MyInteger integerA = new MyInteger(2);
MyInteger integerB = new MyInteger(3);
System.out.println("交换前 -> "+integerA+":"+integerB);
swap(integerA, integerB);
System.out.println("交换前 -> "+integerA+":"+integerB);
public static void swap(MyInteger a,MyInteger b){
MyInteger temp =new MyInteger(a.getNum());//拷贝一份新的值
a.setNum(b.getNum());;//a为b的值
b.setNum(temp.getNum());//b为a的值
}console输出结果：
交换前 -> 2:3
交换前 -> 3:2欣喜若狂，反复倒腾，总算改变了变量a和b的值。oh，my god！但自己的包装类是没法进行Java自动装箱滴，显然类的封装破坏了基本类型的约束，因此该包装是失败的，在实际过程，我们很有可能因为使用这个类导致一些看不到的bug，因此针对swap方法，我们再提出一种新的解决方案，上述解决方案只为了帮助理解引用，指针，参数传递，引用传递的概念。
正解
在很多排序算法中，它们是这么干的！
int[] data = {2,3};
System.out.println("交换前 -> "+data[0]+":"+data[1]);
swap(data, 0,1);
System.out.println("交换前 -> "+data[0]+":"+data[1]);
public static void swap(int[] data, int a, int b) {
int t = data[a];
data[a] = data[b];
data[b] = t;
}这可是结合了指针概念和排序算法的实际应用啊，咱们来谈谈该设计哲学，首先，大多数的排序算法的输入均为一个数组，各种基本类型的组合。因此，swap基本都用在排序算法中，而对数组的传递，实际背后原理是对指针的应用，所以该方法是奏效的。
参考资料
- Swap in JAVA, 不是想象中的简单
- Java传参的值传递和引用传递问题