c/c++和java实现swap函数的不同处

首先我们来看一下在c/c++中实现的swap函数

[cpp]

  1. void  swap ( int & a, int & b)      
  2. {      
  3.     int  Temp;      
  4.     temp = a;      
  5.     a = b;      
  6.     b = temp;      
  7. }  

 

那么在java中是否还能这样呢,很显然java中没有地址引用符号了。

首先我们来看下c/c++和java的区别。

本质区别

C/C++中swap功能的本质:通过传递变量地址(指针或引用)来交换变量地址中的值。

 

Java标榜其中对C/C++一个很大的改进就是:Java对程序员屏蔽了变量地址的概念,减少指针误用。

 

在Java世界中函数或者叫方法的入参都是通过值拷贝的方式进行传递:

  • 原始类型(char,int,double等)都是通过直接拷贝变量值传参;
  • 对象类型都是通过引用拷贝(跟C++中引用不同)传参,通过该引用能够更改其指向的对象内部值,但是更改该引用值,仅对函数内部可见,函数外部的实参依然没有改变;
从上面可以看出通过地址的方式在java中是不可能实现的,因为java严格遵循值传递(pass-by-value)。
 
java传递是引用拷贝,既不是引用本身,更不是对象。
 
但没有解决不了的问题,我们可以利用其他方法来实现:
 
Method1:用数组交换值(对于数组中的元素的交换,所以经常在排序中看到)
[java]

  1. Public  static  void  swap ( int [] Data,  int  a,  int  b) {  
  2.         int  t = Data [a];      
  3.         data [a] = data [b];      
  4.         data [b] = t;      
  5. }  

Method2:用重定义类(自己定义的)

[java]

  1. Class  MyInteger {         
  2.     Private  int  x;     / / the x as the only data member       
  3.     Public  MyInteger ( int  xIn) {x = xIn;}  / / Constructor       
  4.     Public  int  getValue () {  return  x;}   / / get the value        
  5.     Public  void  insertValue ( int  xIn) {x = xIn;}  / / change the value of the      
  6. }      
  7.    
  8. Public  Class  Swapping {         
  9.     / / Swap: pass object references       
  10.     static  void  swap (MyInteger rWrap, MyInteger sWrap) {            
  11.         / / Change the value of the process           
  12.         int  t = rWrap.getValue ();            
  13.         rWrap.insertValue (sWrap.getValue ());            
  14.         sWrap.insertValue (t);         
  15.     }         
  16.     Public  static  void  main (String [] args) {            
  17.         int  a =  23 , b =  47 ;            
  18.         System.out.println ( “Before. a:”  + a +  “, b:”  + b);            
  19.         MyInteger AWRAP =  new  MyInteger (a);            
  20.         MyInteger bWrap =  new  MyInteger (b);            
  21.         swap (aWrap, bWrap);            
  22.         a = aWrap.getValue ();            
  23.         b = bWrap.getValue ();            
  24.         System.out.println ( “After. a:”  + a +  “, b:”  + b);         
  25.     }      
  26. }  

Method3:外部内联法

[java]

  1. Public  Class  Swap2 {       
  2.     Public  static  void  main (String args []) {       
  3.         Swap2 SW =  new  Swap2 ( 1 , 2 );       
  4.         System.out.println ( “i is”  + sw.i);       
  5.         System.out.println ( “J is”  + sw.j);       
  6.         sw.swap ();       
  7.         System.out.println ( “i is”  + sw.i);       
  8.         System.out.println ( “J is”  + sw.j);       
  9.     }       
  10.     int  i, J;       
  11.     Public  Swap2 ( int  i,  int  J) {       
  12.         this . i = i;       
  13.         this . J = J;       
  14.     }       
  15.    
  16.     Public   void  swap () {       
  17.         int  Temp;       
  18.         temp = i;       
  19.         i = j;       
  20.         j = temp;       
  21.     }       
  22. }       
  23.    
  24. Public  Class  swap1 {       
  25.     Public  static  void  swap1 (Integer a, Integer b) {       
  26.         Integer temp = a;       
  27.         a = b;       
  28.         b = temp;       
  29.     }       
  30.     Public   static   void  main (String args []) {       
  31.         Integer a, b;       
  32.         a =  new  Integer ( 10 );       
  33.         b =  new  Integer ( 20 );       
  34.         Swap1.Swap1 (a, b);       
  35.         System.out.println ( “a is”  + a);       
  36.         System.out.println ( “b is”  + b);       
  37.     }       
  38. }  
总结:
数组中的元素交换,可以使用下文中的public static void swap(int[] data, int a, int b)方法;
非数组中的元素交换,可以使用最原始的交换方法,可以实现交换;也可以使用上面提到的重定义类的方式、外部内联的方式,视情况而定

标签