Question

如果没有可以通过引用传递的方法，如何在java中创建swap函数？有人可以给我一个代码吗？

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

但是由于java传递值

，因此不会反映出这种变化

Answer 1

我认为这是最接近简单交换的，但它没有简单的使用模式：

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

y = swap(x, x=y);

它依赖于x在将swap分配给y之前传入x的事实，然后返回x并将其分配给{{ 1}}。

您可以将其设为通用并交换任意数量的相同类型的对象：

Answer 2

您无法创建方法交换，因此在调用swap(x,y)之后，将交换x和y的值。您可以通过交换内容来为可变类创建这样的方法，但这不会改变它们的对象标识，也无法为此定义一般方法。

但是，您可以编写一个方法，在数组或列表中交换两个项目，如果这是您想要的。

¹例如，您可以创建一个带有两个列表的交换方法，并且在执行该方法之后，列表x将具有列表y的先前内容，列表y将具有列表x的先前内容。

Answer 3

这取决于你想做什么。此代码交换数组的两个元素。

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);
}

这样的内容交换了某些x类的y和Point字段：

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

Answer 4

显然我在Dansalmo's answer上没有足够的声誉点来评论，但这是一个很好的声誉，虽然名字错误。他的回答实际上是K-combinator。

#wrap {
    display: flex;
    justify-content: center;
    width: 100%;
}
#left, #right {
    padding: 20px;
    width:25%;
    min-width:300px;
    float:left;
}
@media screen and (max-width: 600px) {
    #left {
        float:none;
        width:auto;
        margin:0 auto;
    }
    #right {
        float:none;
        width:auto;
        margin:50px auto;
    }
}

JLS is specific about argument evaluation when passing to methods/ctors/etc。（在较旧的规格中，情况不是这样吗？）

当然，这是一个功能性习语，但对于那些认识它的人来说已经足够清楚了。（如果你不理解你找到的代码，请不要搞乱它！）

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

K-combinator专为此类设计而设计。 AFAIK没有理由不通过代码审查。

我的0.02美元。

Answer 5

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 6

我可能会做类似以下的事情。当然，有了丰富的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 7

试试这个魔法

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);

Answer 8

对于整数类型，您可以这样做

a ^= b;
b ^= a;
a ^= b;

使用按位异或运算符^。与所有其他建议一样，您可能不应该在生产代码中使用它。

由于我不知道的原因，单行版本a ^= b ^= a ^= b不起作用（也许我的Java编译器有错误）。单行代码在C语言中与我尝试过的所有编译器一起工作。但是，可以使用两行版本：

a ^= b ^= a;
b ^= a;

以及

b ^= a;
a ^= b ^= a;

一个有效的证明：令a₀和b₀为a和b的初始值。在第一行之后，a是a₁=a₀xorb₀;在第二行之后，b为b₁=b₀xora₁=b₀xor（a₀xorb₀）=a₀。在第三行之后，a是a2 =a₁xorb₁=a₁xor（b₀xora₁）=b₀。

用于交换原语的Java方法

8 个答案: