Java 在适当的位置交换号码

我是Java新手，所以问题是。 我正在尝试交换两个数字，而不使用第三个临时变量。代码相当简单

public static void swapInPlace(int a, int b){
        a = a + b;
        b = a - b;
        a = a - b;
    }

    public static void main(String[] args) {
    // write your code here
        int a = 12;
        int b = 7;
        swapInPlace(a, b);
        System.out.println("a: " + a + " b: " + b);

    }

该逻辑在调试器中运行良好，但为a和b输出相同的值。我知道同样的情况也在发生，因为swapInPlace函数使用了复制的值

现在，如果我必须使这个函数在C++中工作，我只会把方法签名改为< /p>

public static void swapInPlace(int& a, int& b)

---

但是，由于java无法实现这一点，我的问题是如何在java中实现这一点。

java总是按值传递。但在某些情况下，您传递的是引用，因此可以更改对象的内容

例如，您可以将AtomicInteger用作int的可变包装器

import java.util.concurrent.atomic.AtomicInteger;

public class SwapInPlaceMain {
    public static void swapInPlace(AtomicInteger a, AtomicInteger b) {
        a.set(a.get() + b.get());
        b.set(a.get() - b.get());
        a.set(a.get() - b.get());
    }

    public static void main(String[] args) {
        // write your code here
        AtomicInteger a = new AtomicInteger(12);
        AtomicInteger b = new AtomicInteger(7);
        swapInPlace(a, b);
        System.out.println("a: " + a + " b: " + b);
    }
}

---

Java总是通过值传递。但在某些情况下，您传递的是引用，因此可以更改对象的内容

例如，您可以将AtomicInteger用作int的可变包装器

import java.util.concurrent.atomic.AtomicInteger;

public class SwapInPlaceMain {
    public static void swapInPlace(AtomicInteger a, AtomicInteger b) {
        a.set(a.get() + b.get());
        b.set(a.get() - b.get());
        a.set(a.get() - b.get());
    }

    public static void main(String[] args) {
        // write your code here
        AtomicInteger a = new AtomicInteger(12);
        AtomicInteger b = new AtomicInteger(7);
        swapInPlace(a, b);
        System.out.println("a: " + a + " b: " + b);
    }
}

---

正如其他答案所说，您需要使用包装器。这是一个关于如何做到这一点的简短示例

private class IntWrap{
    int value;

    public IntWrap(int v){ this.value=v; }
}

public static void swapInPlace(IntWrap a, IntWrap b){
    a.value = a.value + b.value;
    b.value = a.value - b.value;
    a.value = a.value - b.value;
}

public static void main(String[] args) {
    IntWrap a = new IntWrap(12);
    IntWrap b = new IntWrap(7);
    swapInPlace(a, b);
    System.out.println("a: " + a.value + " b: " + b.value);

}

---

正如其他答案所说，您需要使用包装器。这是一个关于如何做到这一点的简短示例

private class IntWrap{
    int value;

    public IntWrap(int v){ this.value=v; }
}

public static void swapInPlace(IntWrap a, IntWrap b){
    a.value = a.value + b.value;
    b.value = a.value - b.value;
    a.value = a.value - b.value;
}

public static void main(String[] args) {
    IntWrap a = new IntWrap(12);
    IntWrap b = new IntWrap(7);
    swapInPlace(a, b);
    System.out.println("a: " + a.value + " b: " + b.value);

}

---

您有两个选项，创建一个内部类并为其创建一个对象，这个类可以同时包含两个变量并在

swapInPlace（）方法中返回对象

另一种可能是传递数组，例如：

class Swap {
    public static void swapInPlace(int array[]){
        array[0] = array[0] + array[1];
        array[1] = array[0] - array[1];
        array[0] = array[0] - array[1];
    }

    public static void main(String[] args) {
    // write your code here
        int array[] = new int []{12, 7};
        swapInPlace(array);
        System.out.println("a: " + array[0] + " b: " + array[1]);

    }
}

上述程序的输出为：

a: 7 b: 12

您有两个选项，创建一个内部类并为其创建一个对象，这个类可以同时包含两个变量并在
swapInPlace（）方法中返回对象

另一种可能是传递数组，例如：

class Swap {
    public static void swapInPlace(int array[]){
        array[0] = array[0] + array[1];
        array[1] = array[0] - array[1];
        array[0] = array[0] - array[1];
    }

    public static void main(String[] args) {
    // write your code here
        int array[] = new int []{12, 7};
        swapInPlace(array);
        System.out.println("a: " + array[0] + " b: " + array[1]);

    }
}

上述程序的输出为：

a: 7 b: 12

实现这一点的一种（可能有争议的）方法是使用宏预处理器

默认情况下，Java可能不包括对宏的支持，但没有任何东西阻止您使用预处理器。我自己也经常在Java中使用C预处理器

值得注意的是，当有人提出这个建议时，爪哇人往往会口吐白沫。这并没有什么合理的理由，但我一直担心，因为预处理器是完全合法的编程工具。Java编译器对预处理器不友好，但有一些方法可以解决这个问题（我为此编写了一个编译器修改，但不需要使用预处理器，这对我来说很方便）

有很多预处理器。值得注意的选择是C预处理器和。古老的M4系统也跃入人们的脑海。
实现这一点的一种（可能有争议的）方法就是使用宏预处理器

默认情况下，Java可能不包括对宏的支持，但没有任何东西阻止您使用预处理器。我自己也经常在Java中使用C预处理器

值得注意的是，当有人提出这个建议时，爪哇人往往会口吐白沫。这并没有什么合理的理由，但我一直担心，因为预处理器是完全合法的编程工具。Java编译器对预处理器不友好，但有一些方法可以解决这个问题（我为此编写了一个编译器修改，但不需要使用预处理器，这对我来说很方便）

有很多预处理器。值得注意的选择是C预处理器和。古老的M4系统也跃入人们的脑海。
我想您忘记了通过“引用”将值发送到函数。您传递的是值，而不是它们的引用地址，因此即使在调用函数后，值也不会更改

此代码将对您的问题进行排序

public static void swapInPlace(int &a, int &b){
        a = a + b;
        b = a - b;
        a = a - b;
    }

    public static void main(String[] args) {
    // write your code here
        int a = 12;
        int b = 7;
        swapInPlace(a, b);
        System.out.println("a: " + a + " b: " + b);

    }

我认为您忘记了通过“引用”将值发送到函数。您传递的是值，而不是它们的引用地址，因此即使在调用函数后，值也不会更改

此代码将对您的问题进行排序

public static void swapInPlace(int &a, int &b){
        a = a + b;
        b = a - b;
        a = a - b;
    }

    public static void main(String[] args) {
    // write your code here
        int a = 12;
        int b = 7;
        swapInPlace(a, b);
        System.out.println("a: " + a + " b: " + b);

    }

简单的回答是，要么你不能，要么你必须为
int
使用包装类，才能使用对对象的引用。@KevinEsche我从来没有想过这一点，但是使用
Integer
会起作用吗？@MrHug不，不会。这与您希望对
字符串使用交换函数相同。使用
整数也不起作用。@KevinEsche好的，谢谢，只是不确定并想检查：）简单的答案是要么你不能，要么你必须为
int
使用包装类才能使用对对象的引用。@KevinEsche我从来没有想过这一点，但是使用
Integer
行得通吗？@MrHug不，不行。这与您希望对
字符串使用swap函数相同。使用
整数
也不起作用。@KevinEsche好的，谢谢，只是不确定并想检查：）使用原子整数是否存在开销问题（由于并发特性）？为什么不创建一个内部类作为包装器呢？就性能而言，应该会有更好的结果，不是吗？@BlueMoon93当然。我的意思是，这仅仅是出于示例目的。@BlueMoon93 TS代码显然遇到了溢出问题，因此不需要进一步优化。TS代表主题启动器。不知道这是不是一般的缩写。啊！我相信OP（原始海报）在这里更常见，但无论如何还是要感谢：PIs使用原子整数没有开销问题（由于并发特性）？为什么不创建一个内部类作为包装器呢？就性能而言，应该会有更好的结果，不是吗？@BlueMoon93当然。我的意思是，这仅仅是出于示例目的。@BlueMoon93 TS代码显然遇到了溢出问题，因此不需要进一步优化。TS代表主题启动器。不知道这是不是一般的缩写。啊！我相信OP（原创海报）在这里更常见，不过还是要谢谢你：P