敢不敢说你全部能看懂？

关于整形(int)不使用中间变量相信大家有常用的算法，比如
1最常用的：
public static void main(String[] args) {
int a = 5;
int b = 4;
a = a^b;
b = b^a;
a = a^b;
System.out.print(a + ":" + b);
}
这个是最快的其次不是很好但是可行的
public static void main(String[] args) {
int a = 5;
int b = 4;
a = a+b;
b = a-b;
a = a-b;
System.out.print(a + ":" + b);
}和
public static void main(String[] args) {
int a = 5;
int b = 4;
a = a * b;
b = a / b;
a = a / b;
System.out.print(a + ":" + b);
}
这2种可能会内存溢出，不建议使用最后一种，可能大家没看过的，可能是最难理解的：
public static void main(String[] args) {
int a = 5;
int b = 4;
b = a + 0 * (a = b);
System.out.print(a + ":" + b);
}

解决方案 »

免费领取超大流量手机卡，每月29元包185G流量+100分钟通话, 中国电信官方发货

除了最后一种不怎么懂-。-但在以前的帖子里找到了
http://topic.csdn.net/u/20070929/13/97529154-be2f-431e-a2bd-d7ccd048cf77.html
差不多吧？
第三种很难理解吗？只不过用了下赋值，然后又要把赋值后的a去掉就乘0，然后b = a(原值)。话说有点像孔乙己的做法。
第一种在C/C++用的比较多，java应该少见，我的个人认为，我只是说出有这种方法而已
我觉得第二种的第二个方法出了内存溢出外，还有其他的bug，就是他交换的2个值中是不能有0的存在。
呵呵，楼主说话有误，什么叫很难理解，是很难理解别人想到这种解法，还是理解原理？假如你已经理解了原理，就应该把问题说清楚一点。而且楼主的问题在java解惑中有。
學習对于a=(b=a)*0+b这个式子,本没什么好说的,按逻辑上来说肯定a跟b没有实现交换啦..
但是用C#试了一下,结果大吃一惊,交换了.奇怪,又用C++试了一下,没有交换..
毕竟对错不能按编译器说的算吧,逻辑上应该没交换就是没交换,你交换了,不管你是谁都是错的....
a ,b 互换.最后一种同时赋值a ,b,很强大的想法.崇拜lz.
public class Test {
    public static void main(String[] args) {
        int a = 5;
        int b = 4;
        b = a - b + (a=b);
        System.out.println(a + ":" + b);//4:5
        int c = 5;
        int d = 4;
        d = (c=d) + c - d;
        System.out.println(c + ":" + d);//4:4
    }
}运行顺序，从左到右先赋值计算。
第一种常见，第二种偶尔见，第三种和最后一种没见过
最后一种依赖于编译器，不同编译器结果未必一样（当然java里可能都一样），其实相当于内部使用了临时变量
在vs2010下 ,a,b都是4.第三种算法应该是基于某些特殊的编译器才能实现的,不过也有一定的参考价值.
public static void main(String[] args) {
int a = 5;
int b = 4;
b = a + 0 * (a = b);
System.out.print(a + ":" + b);
}这种算法很犀利啊
4 = 5 + 0 *（5 = 4）; 结果为5  小括号内地结果为4
b = a + 0 * (a = b) ; b=5       a=b即a=4
a = a^b;
^这个符号是干吗的？
首先，Lz这个方法真的很巧妙，以前没用过。我试了几次，然后谈谈我的理解。1、根据运算的优先级首先运行到括号里的表达式(a=b),此时已经把栈中的b的值赋给了a，得到了一个新的a，所以此时完成了第一步.2、然后就是b = a + 0*(a=b);不过就是为了实现交换而编写的一个算法而已，实际上就是b = a +0 ;此时的老a的值赋给了b.这样就完成了交换了。最后，第一次看到这种办法，很巧妙。基础很扎实。
就该像这样说说自己的想法，这个也是我发帖的目的哇，大家交流交流，但是你怎么解释：
b =  0 * (a = b) + a;
按照你的写法这个就等于
b = 0 + a;但是结果却会大不相同。
底层的编译不是这么简单的（针对java，C有些编译这个算法失败）
前面两种都很常见，第一种是最好的速度快而且不会内存溢出，第二种有内存溢出的危险，至于第三种实质就是第二中的模仿，而且做乘除法没有加减法的效率高，没什么用。至于最有一种大概和是java的编译器在实现的特殊之处，b = a + 0 * (a = b)这个明显在c++的就不可以，c++在计算a+0*（a = b）中的加的时候就将a = b这条语句同步到内存里面，所以在a 加0的时候a就等于b了，而java里面可能实现的时候并没有将在a被赋值后同步到内存里面。
我只能这样理解了，不管怎样按照优先级，肯定是先运行(a=b),所以说如果a在前，那么a还是老a，如果a在后的话，那就是新赋值后的a。至于你说的底层是如何编译的，不得而知了，期待大牛通过内存分析的办法来解释下这个编译过程了。
如果能好好的看书，看着三个程序都没有任何压力另外，谁看看这段代码输出啥
p = 1;
p = p++;
System.out.println(p);
还纠结呢？javap -c ，看一下指令就好了。  Code:
   0:   iconst_5  //栈(底-->顶)：5
   1:   istore_1  //5存进变量1
   2:   iconst_4  //栈(底-->顶)：4
   3:   istore_2  //4存进变量2
   4:   iload_1   //5拿到顶  栈(底-->顶)：5
   5:   iconst_0  //0入栈    栈(底-->顶)：5  0
   6:   iload_2   //4拿到顶  栈(底-->顶)：5  0  4
   7:   dup       //复制栈顶元素，入栈  栈(底-->顶)：5  0  4  4
   8:   istore_1  //4存进变量1，到这完成一半了，变量1由5变成4。  栈(底-->顶)：5  0  4
   9:   imul   //栈顶两元素做积，入栈  栈(底-->顶)：5  0
   10:  iadd   //栈顶两元素做和，入栈  栈(底-->顶)：5
   11:  istore_2  //5存变量2中
   12:  return
b = a+0 * (a = b)  ;
b = 0 * (a = b)+a  ;
两者的区别在于：前者先把a的值读入操作栈，用于后来的相加操作，期间修改了a变量的值，却没参与运算
后者就是先修改了a变量的值，做了积之后再从a变量读入数值，进行加法操作。
谁要是在我的项目里写出这样的代码：
b = a + 0 * (a = b);
果断抓去当典型批斗！
第一种第一次见是在李芝兴的《java之程序设计网络编程》上见到，感觉很牛X。
第二种第三中如果是在oj作题，估计都得wa。a+b  a*b像你说的都得溢出。
第三种我认为不是很正确，和编译器有关。就像a=1. b=a+（++a）;b不一定等于3吧。
unspecified behavior
b = a + 0 * (a = b);
没有一个语言规定b必须在a=b之前求值呀
如果编译器优化的时候改变求值顺序，结果就变了
如
a=b;
b=a+0*a;
这样就不对了
没意思。还不如去看 acm 的题目
这个有c的基础都好理解，还好，一般理工科大学都学c。
顺便问一个算法题，假设有个链表，(vector,map,array等)，里面有几百万条记录，每记录是一个class对象,其中有一个变量是int. 假设已知某记录的该变量的值，var=1024. 用什么方法能快速找出这条记录,算法复杂度大约是多少？
       最后一种可能有些问题，得要看编译器，b = a + 0 * (a = b);这个语句编译器它有可能从右到左执行，当然也有可能从左到右（因为编译器会做些一些优化，加法交换律允许加号两边的式子交换，要是编译器把这个语句优化成b=0*(a=b)+a;然后从左到右执行，你这个就错了。）实际应用真的不大，最好别用。
        说真的，讨论这些就是浪费时间，交换变量就可以用个中间变量，不会耽误多少时间（现在的电脑还是能够承担起的，要是怕开销太大，干脆你以后就只用C/C++吧，其他语言本身开销很大），建议新手别看这种无聊贴，浪费时间，把时间放在语言的精髓。（还有要说的就是，上面有些人学的什么编程啊，还见都没见过，连个16的人都比不过，说实话，我只16岁）
java中常看到的是第二种。最后一种真没看到过。