怎么实现两个值的交换~~请大家帮忙

Question

当然,这关系到JAVA传值的特性.如果要改变原来的值,就一定要用数组~改为 static void swap(int[] arg1,int[] arg2)
试试~

Answer 1

其实你在调用这个方法swap(a,b)的时候jvm会帮你复制出两个值 你交换的时候复制出来的两个值
出方法体后这两个值就消失了

Answer 2

在不同的java新闻组中，参数是传值还是传址一直是一个经常被争辩的话题。误解的中心是以下两个事实：  
 
1、对象是传引用的  
 
2、参数是传值的  
 
这两个能够同时成立吗？一个字：是！在java中，你从来没有传递对象，你传递的仅仅是对象的引用！一句话，java是传引用的。然而，当你传递一个参数，那么只有一种参数传递机制：传值！  
 
 
通常，当程序员讨论传值和传引用时，他们是指语言的参数传递机制，c++同时支持这两种机制，因此，以前使用过c++的程序员开始好像不能确定的java是如何传参数的。java语言为了事情变得简单只支持参数传值的机制。  
 
java中的变量有两种类型：引用类型和原始类型。当他们被作为参数传递给方法时，他们都是传值的。这是一个非常重要的差别，下面的代码范例将说明这一点。  
 
在继续前，我们有必要定义一下传值和传引用。传值意味着当参数被传递给一个方法或者函数时，方法或者函数接收到的是原始值的副本。因此，如果方法或者函数修改了参数，受影响的只是副本，原始值保持不变。  
 
关于java中的参数传递的混乱是因为很多java程序员是从c++转变过来的。c++有引用和非引用类型的变量，并且分别是通过传引用和传值得。java语言有原始类型和对象引用，那么，按照逻辑，java对于原始类型使用传值而对引用是传引用的，就像c++一样。毕竟，你会想到如果你正在传递一个引用，那么它一定是传引用的。这是一个很诱惑人的想法，但是是错误的！  
 
在c++和java中，当函数的参数不是引用时，你传递的是值得副本（传值）。但是对于引用类型就不同了。在c++中，当参数是引用类型，你传递的是引用或者内存地址（传引用），而在java中，传递一个引用类型的参数的结果只是传递引用的副本（传值）而非引用自身。这是一个非常重要的区别！java不考虑参数的类型，一律传递参数的副本。  
 
仍然不信？如果java中是传引用，那么下面的范例中的swap方法将交换他们的参数。因为是传值，因此这个方法不是像期望的那样正常工作。  
 
 
class  Swap  
{  
public  static  void  main(String  args[])    
{    
Integer  a,  b;    
int  i,j;  
a  =  new  Integer(10);  
b  =  new  Integer(50);    
i  =  5;  
j  =  9;    
System.out.println("Before  Swap,  a  is  "  +  a);    
System.out.println("Before  Swap,  b  is  "  +  b);    
swap(a,  b);    
System.out.println("After  Swap  a  is  "  +  a);    
System.out.println("After  Swap  b  is  "  +  b);    
System.out.println("Before  Swap  i  is  "  +  i);    
System.out.println("Before  Swap  j  is  "  +  j);    
swap(i,j);    
System.out.println("After  Swap  i  is  "  +  i);  
System.out.println("After  Swap  j  is  "  +  j);    
}  
public  static  void  swap(Integer  ia,  Integer  ib)  
{  
Integer  temp  =  ia;    
ia  =  ib;    
ib  =  temp;    
}  
public  static  void  swap(int  li,  int  lj)    
{    
int  temp  =  li;    
li  =  lj;    
lj  =  temp;    
}    
}    
 
 
 
上面程序的输出是:    
 
 
Before  Swap,  a  is  10    
Before  Swap,  b  is  50  
After  Swap  a  is  10    
After  Swap  b  is  50    
Before  Swap  i  is  5    
Before  Swap  j  is  9    
After  Swap  i  is  5    
After  Swap  j  is  9    
 
 
因为swap方法接收到的是引用参数的副本（传值），对他们的修改不会反射到调用代码。  
 
 
译者注：在传递引用和原始类型时还是有不同的，考虑以下的代码：    
 
class  Change  
{  
public  static  void  main(String  args[])    
{    
StringBuffer  a=new  StringBuffer("ok");    
int  i;  
i  =  5;  
System.out.println("Before  change,  a  is  "  +  a);    
change(a);    
System.out.println("After  change  a  is  "  +  a);    
System.out.println("Before  change  i  is  "  +  i);    
change(i);    
System.out.println("After  change  i  is  "  +  i);  
}  
public  static  void  change(StringBuffer  ia)  
{  
ia.append("  ok?");  
}  
public  static  void  change(int  li)    
{    
li  =  10;    
}    
}  
 
 
程序的输出为：  
 
 
Before  change,  a  is  ok  
After  change  a  is  ok  ok?  
Before  change  i  is  5  
After  change  i  is  5  
 
 
，即如果传递的是引用，那么可以修改引用对象的内容，这个改变会影响到原来的对象，而传递的如果是原始类型则不会有影响。这个也是造成误解的原因之一吧。    
 
版权声明    
 
 
 
Re:  破除java神话之二：参数是传址的（翻译）    
subwater  积分:  1  发表时间:  Jun  27,  2002  9:35  PM  评论    
 
我个人觉得觉得作者有些弯曲了传址的概念，其实C++里也是同样的。如下面的代码：    
 
//example  1    
#include    
void  exch(int  *p1,int  *p2);    
 
int  main()    
{    
int  i  =1,j=2;    
cout<<"i="<  return  0;    
}    
 
void  exch(int  *p1,int  *p2)    
{    
int*  temp;    
temp  =  p1;    
p1  =  p2;    
p2  =  temp;    
}    
//end  example  1    
 
结果会是：    
i=1,j=2    
i=1,j=2    
 
同样不会发生任何变化，正确的写法应该是    
 
//example  2    
#include    
void  exch(int  *p1,int  *p2);    
 
int  main()    
{    
int  i  =1,j=2;    
cout<<"i="<  return  0;    
}    
 
void  exch(int  *p1,int  *p2)    
{    
int  temp;    
temp  =  *p1;    
*p1  =  *p2;    
*p2  =  temp;    
}    
//end  example  2    
结果会是：    
i=1,j=2    
i=2,j=1    
 
 
如上面代码说明的一样，其实无论何种语言传址方法都是一样的。传值和传址都是把内容复制给形参。只是传值复制得是变量的具体的值，而传址复制的是存放给变量的地址。你只是改变了形参里的地址，变量当然没有变化，你只有改变该地址里的值，才可以改变该变量的值。    
C++里如果要改变两个地址，应该传的是个指向指针的指针。如下面的代码：    
//example  2    
#include    
void  exch(int  **p1,int  **p2);    
 
int  main()    
{    
int  a  =1,b  =  2;    
int  *i  =  &a;    
int  *j  =  &b;    
cout<<"a="<  return  0;    
}    
 
void  exch(int  **p1,int  **p2)    
{    
int*  temp;    
temp  =  *p1;    
*p1  =  *p2;    
*p2  =  *temp;    
}    
//end  example  2    
结果会是：    
a=1,b=2    
*i=1,*j=2    
a=1,b=2    
*i=2,*j=1    
 
而Java中可以用这样的例子：    
public  class  Test    
{    
public  static  void  swap(Integer[]  a)    
{    
Integer  temp=  a[0];    
a[0]  =  a[1];    
a[1]  =  temp;    
}    
 
public  static  void  main(String[]  args)    
{    
Integer[]  one  =  new  Integer[2];    
one[0]  =  new  Integer(17);    
one[1]  =  new  Integer(3);    
System.out.println("before  swap");    
System.out.println("one[0]  is"+one[0]);    
System.out.println("one[1]  is"+one[1]);    
swap(one);    
System.out.println("after  swap");    
System.out.println("one[0]  is"+one[0]);    
System.out.println("one[1]  is"+one[1]);    
}    
}    
结果是：    
before  swap    
one[0]  is  17    
one[1]  is  3    
after  swap    
one[0]  is  3    
one[1]  is  17