如何在java中創建我的交換功能？

Question

如何讓我的交換功能在Java中，如果沒有方法，通過它，我們可以通過引用傳遞？有人可以給我一個代碼嗎？

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

但由於Java經過值

Answer 1

你不能創建一個方法交換，所以在調用swap(x,y)之後x和y的值將被交換。你可以通過交換它們的contents¹創建可變類這樣的方法，但是這不會改變自己的對象標識，你不能爲這個定義的一般方法。

但是你可以寫在交換一個數組或列表的兩個項目，如果這就是你想要的東西的方法。

¹例如，你可以創建一個交換方法，它採用兩個列表和執行方法之後，名單x將有名單Y的以前的內容，並列出ÿ將列表x的以前的內容。

Answer 2

這取決於你想做什麼變化不會被反射回來。這段代碼交換了一個數組的兩個元素。

void swap(int i, int j, int[] arr) { 
    int t = arr[i]; 
    arr[i] = arr[j]; 
    arr[j] = t; 
} 

像這樣的東西交換了等長的兩個int[]的內容。

void swap(int[] arr1, int[] arr2) { 
    int[] t = arr1.clone(); 
    System.arraycopy(arr2, 0, arr1, 0, t.length); 
    System.arraycopy(t, 0, arr2, 0, t.length); 
} 

像這樣交換兩個BitSet的內容（使用XOR swap algorithm）：

void swap(BitSet s1, BitSet s2) { 
    s1.xor(s2); 
    s2.xor(s1); 
    s1.xor(s2); 
} 

像這樣的東西交換一些Point類的x和y領域：

void swapXY(Point p) { 
    int t = p.x; 
    p.x = p.y; 
    p.y = t; 
} 

Answer 3

我可能會做一些像下面這樣。當然，有了豐富的Collection類，我無法想象在任何實際的代碼中都需要使用它。

public class Shift { 
    public static <T> T[] left (final T... i) { 
    if (1 >= i.length) { 
     return i; 
    } 
    final T t = i[0]; 
    int x = 0; 
    for (; x < i.length - 1; x++) { 
     i[x] = i[x + 1]; 
    } 
    i[x] = t; 
    return i; 
    } 
} 

兩個參數調用，它是一種交換。

它可以如下使用：

int x = 1; 
int y = 2; 
Integer[] yx = Shift.left(x,y); 

或者：

Integer[] yx = {x,y}; 
Shift.left(yx); 

然後

x = yx[0]; 
y = yx[1]; 

注：它自動箱原語。

Answer 4

我覺得這是你可以得到一個簡單的互換最接近的，但它並沒有一個簡單的使用模式：

int swap(int a, int b) { // usage: y = swap(x, x=y); 
    return a; 
} 

y = swap(x, x=y); 

它依賴於一個事實，即x將進入swapy之前被分配到x，然後x返回並分配給y。

你可以使它通用和交換任何數量的相同類型的對象：

<T> T swap(T... args) { // usage: z = swap(a, a=b, b=c, ... y=z); 
    return args[0]; 
} 

c = swap(a, a=b, b=c) 

Answer 5

public class Swap1 { 
    public static void main(String[] args){ 
     int x =7; 
     int y = 3; 

     swap(x,y); 

     System.out.println("x = " + x); 
     System.out.println("y = " + y); 
    } 

    public static void swap(int x, int y) { 
     int temp = x; 
     x = y; 
     y = temp; 
    } 
} 

Answer 6

顯然，我沒有足夠的信譽分評論上Dansalmo's answer，但它是一個不錯，但錯誤。他的回答實際上是一個K-combinator。

int K(int a, int b) { 
    return a; 
} 

該JLS is specific about argument evaluation when passing to methods/ctors/etc。 （這是不是在舊的規格？）

當然，這是一個功能成語，但它已經足夠清楚，以識別它的人。 （如果你不明白你找到的代碼，不要猴子吧！）

y = K(x, x=y); // swap x and y 

的K-組合子是專門爲這種事情而設計的。 AFAIK沒有理由不通過代碼審查。

我的$ 0.02。

Answer 7

AFAIS，沒有人提到atomic reference。

整數

public void swap(AtomicInteger a, AtomicInteger b){ 
    a.set(b.getAndSet(a.get())); 
} 

字符串

public void swap(AtomicReference<String> a, AtomicReference<String> b){ 
    a.set(b.getAndSet(a.get())); 
} 

Answer 8

試試這個神奇的

public static <T> void swap(T a, T b) { 
    try { 
     Field[] fields = a.getClass().getDeclaredFields(); 
     for (Field field : fields) { 
      field.setAccessible(true); 
      Object temp = field.get(a); 
      field.set(a, field.get(b)); 
      field.set(b, temp); 
     } 
    } catch (IllegalAccessException e) { 
     e.printStackTrace(); 
    } 
} 

和測試吧！

System.out.println("a:" + a); 
    System.out.println("b:" + b); 
    swap(a,b); 
    System.out.println("a:" + a); 
    System.out.println("b:" + b);