第一种通过中间值
int a = 5;
int b = 10;
int temp;

temp = a;
a = b;
b = temp;
第二种通过相加
int a = 5;
int b = 10;

a = a + b;
b = a - b;
a = a - b;

第三种通过异或
int a = 5;
int b = 10;

a = a^b;
b = a^b;
a = a^b;

Java并发API提供了一种允许2个并发任务间相互交换数据的同步应用。更具体的说，Exchanger类允许在2个线程间定义同步点，当2个线程到达这个点，他们相互交换数据类型，使用第一个线程的数据类型变成第二个的，然后第二个线程的数据类型变成第一个的。
用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交换数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才能彼此交换数据。
package com.ljq.test.thread;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExchangerTest {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final Exchanger exchanger = new Exchanger();
service.execute(new Runnable(){
public void run() {
try {
String data1 = "张三";
System.out.println("线程" + Thread.currentThread().getName() + "正在把数据'" + data1 +"'换出去");
Thread.sleep((long)(Math.random()*10000));
String data2 = (String)exchanger.exchange(data1);
System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为'" + data2+"'");
}catch(Exception e){
}
}
});
service.execute(new Runnable(){
public void run() {
try {
String data1 = "李四";
System.out.println("线程" + Thread.currentThread().getName() + "正在把数据'" + data1 +"'换出去");
Thread.sleep((long)(Math.random()*10000));
String data2 = (String)exchanger.exchange(data1);
System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为'" + data2 + "'");
}catch(Exception e){
}
}
});
}
}
返回结果：
线程pool-1-thread-1正在把数据'张三'换出去
线程pool-1-thread-2正在把数据'李四'换出去
线程pool-1-thread-1换回的数据为'李四'
线程pool-1-thread-2换回的数据为'张三'

int a = 34423;
int b = 24345;
a = a ^ b;
b = b ^ a;
a = a ^ b;
如果采用常规算法：
int temp=a;
a = b;
b =temp;
计算效率：
测试方法
import org.freebencher.FbJobResult;
import org.freebencher.FbTarget;
import org.freebencher.Freebencher;
import org.junit.Test;
/**
* Vincent 创建于 2016/4/15.
*/
public class DemoTest {
@Test
public void swap() {
FbJobResult result = Freebencher.benchmark(new FbTarget() { //the behavior
public boolean invoke() {
int a = 34423;
int b = 24345;
test1(a, b);
//   test2(a, b);
return true;
}
}, 20, // concurrency,
500000 // number of tests to run
);
System.out.println(result.report());
}
private static void test1(int a, int b) {
a = a ^ b;
b = b ^ a;
a = a ^ b;
}
private static void test2(int a, int b) {
int temp = a;
a = b;
b = temp;
}
}
第一种方法：
Test completed.
Disconnected from the target VM, address: '127.0.0.1:63459', transport: 'socket'
Concurrency:             20
Time taken for tests:    89801ms
Successful tests:        500000
Failed tests:            0
Tests per second:        5567.866727542009
Mean time per test:      4.4E-5ms
Percentage of the test finished within a certain time (ms)
50%:                     0
60%:                     0
70%:                     0
80%:                     0
90%:                     0
95%:                     0
98%:                     0
99%:                     0
100%:                    2
第二章方法：
Test completed.
Concurrency:             20
Time taken for tests:    90237ms
Successful tests:        500000
Failed tests:            0
Tests per second:        5540.964349435376
Mean time per test:      3.0E-5ms
Percentage of the test finished within a certain time (ms)
50%:                     0
60%:                     0
70%:                     0
80%:                     0
90%:                     0
95%:                     0
98%:                     0
99%:                     0
100%:                    1
第一种方法比第二种有微弱优势，推荐第一种

还是先看题吧：
package test.java;
public class test8 {
static String a = "yes";
static String b ="no";
public static void main(String[] args) {
jh(a,b);
System.out.println("a:" + a + "b:" + b);
}
private static void jh(String a, String b) {
String c = a;
a = b;
b = c;
}
}
print打印出来的 a 和 b 应该是什么值呢？
A: a:yes ; b:no
B: a:no ; b:yes
---------------------------------------------------------------------------------分割线-------------------------------------------------------------------------------
答案显而易见：A
那么问题来了，是为什么呢？
这个就得说到JAVA传递参数的方式了，很多程序提供了两种参数传递方式：1、值调用，2、引用调用
上面这段代码，jh 方法中的参数 a 和 b 被初始化为两个对象(a和b)的引用的拷贝，并没有调用声明的 a 和 b 的引用，
所以，在jh 交换时，实质上交换的是这两个拷贝，并没有交易换原 a 和 b 的引用。
故答案是：A