c/c++和java實現swap函數的不同處

首先我們來看一下在c/c++中實現的swap函數

void  swap ( int & a, int & b)    
{    
    int  Temp;    
    temp = a;    
    a = b;    
    b = temp;    
}

那麼在java中是否還能這樣呢，很顯然java中沒有地址引用符號了。

首先我們來看下c/c++和java的區別。

本質區別

C/C++中swap功能的本質：通過傳遞變量地址(指針或引用)來交換變量地址中的值。

Java標榜其中對C/C++一個很大的改進就是：Java對程序員屏蔽了變量地址的概念，減少指針誤用。

在Java世界中函數或者叫方法的入參都是通過值拷貝的方式進行傳遞：

• 原始類型(char，int，double等）都是通過直接拷貝變量值傳參；
• 對象類型都是通過引用拷貝(跟C++中引用不同)傳參，通過該引用能夠更改其指向的對象內部值，但是更改該引用值，僅對函數內部可見，函數外部的實參依然沒有改變；

從上面可以看出通過地址的方式在java中是不可能實現的，因爲java嚴格遵循值傳遞(pass-by-value)。

java傳遞是引用的拷貝，既不是引用本身，更不是對象。

但沒有解決不了的問題，我們可以利用其他方法來實現：

Method1：用數組交換值（對於數組中的元素的交換，所以經常在排序中看到）

Public  static  void  swap ( int [] Data,  int  a,  int  b) {
        int  t = Data [a];    
        data [a] = data [b];    
        data [b] = t;    
}

Method2：用重定義類（自己定義的）

Class  MyInteger {       
    Private  int  x;     / / the x as the only data member     
    Public  MyInteger ( int  xIn) {x = xIn;}  / / Constructor     
    Public  int  getValue () {  return  x;}   / / get the value      
    Public  void  insertValue ( int  xIn) {x = xIn;}  / / change the value of the    
}    
 
Public  Class  Swapping {       
    / / Swap: pass object references     
    static  void  swap (MyInteger rWrap, MyInteger sWrap) {          
        / / Change the value of the process         
        int  t = rWrap.getValue ();          
        rWrap.insertValue (sWrap.getValue ());          
        sWrap.insertValue (t);       
    }       
    Public  static  void  main (String [] args) {          
        int  a =  23 , b =  47 ;          
        System.out.println ( "Before. a:"  + a +  ", b:"  + b);          
        MyInteger AWRAP =  new  MyInteger (a);          
        MyInteger bWrap =  new  MyInteger (b);          
        swap (aWrap, bWrap);          
        a = aWrap.getValue ();          
        b = bWrap.getValue ();          
        System.out.println ( "After. a:"  + a +  ", b:"  + b);       
    }    
}

Method3：外部內聯法

Public  Class  Swap2 {     
    Public  static  void  main (String args []) {     
        Swap2 SW =  new  Swap2 ( 1 , 2 );     
        System.out.println ( "i is"  + sw.i);     
        System.out.println ( "J is"  + sw.j);     
        sw.swap ();     
        System.out.println ( "i is"  + sw.i);     
        System.out.println ( "J is"  + sw.j);     
    }     
    int  i, J;     
    Public  Swap2 ( int  i,  int  J) {     
        this . i = i;     
        this . J = J;     
    }     
 
    Public   void  swap () {     
        int  Temp;     
        temp = i;     
        i = j;     
        j = temp;     
    }     
}     
 
Public  Class  swap1 {     
    Public  static  void  swap1 (Integer a, Integer b) {     
        Integer temp = a;     
        a = b;     
        b = temp;     
    }     
    Public   static   void  main (String args []) {     
        Integer a, b;     
        a =  new  Integer ( 10 );     
        b =  new  Integer ( 20 );     
        Swap1.Swap1 (a, b);     
        System.out.println ( "a is"  + a);     
        System.out.println ( "b is"  + b);     
    }     
}

總結：

數組中的元素交換，可以使用下文中的public static void swap(int[] data, int a, int b)方法；
非數組中的元素交換，可以使用最原始的交換方法，可以實現交換；也可以使用上面提到的重定義類的方式、外部內聯的方式，視情況而定