如何用Java编写基本的交换函数[重复]

Question

我是 Java 新手。如何编写以下 C 代码的 java 等价物。

void Swap(int *p, int *q)
{
   int temp;
   temp = *p;
   *p = *q;
   *q = temp;
} 

Answer 1

这里有一个技巧：

public static int getItself(int itself, int dummy)
{
    return itself;
}

public static void main(String[] args)
{
    int a = 10;
    int b = 20;

    a = getItself(b, b = a);
}

Answer 2

对两个整数进行排序

简短的回答是：你不能那样做，java 没有指针。

但是你可以做一些类似的事情：

public void swap(AtomicInteger a, AtomicInteger b){
    // look mom, no tmp variables needed
    a.set(b.getAndSet(a.get()));
}

您可以对所有类型的容器对象（如集合和数组或具有 int 属性的自定义对象）执行此操作，但不能使用基元及其包装器（因为它们都是不可变的）。但我想，让它成为单线的唯一方法是使用 AtomicInteger。

顺便说一句：如果你的数据恰好是一个列表，更好的交换方法是使用Collections.swap(List, int, int)：

Swaps the elements at the specified positions in the specified list.
(If the specified positions are equal, invoking this method leaves
the list unchanged.)

Parameters:
    list - The list in which to swap elements.
    i - the index of one element to be swapped.
    j - the index of the other element to be swapped. 

---

对 int[] 数组进行排序

显然，真正的目标是对整数数组进行排序。 那是与Arrays.sort(int[]) 的单行代码：

int[] arr = {2,3,1,378,19,25};
Arrays.sort(arr);

检查输出：

System.out.println(Arrays.toString(arr));
// [1, 2, 3, 19, 25, 378]

---

这是一个简单的辅助函数，用于交换整数数组中的两个位置：

public static void swap(final int[] arr, final int pos1, final int pos2){
    final int temp = arr[pos1];
    arr[pos1] = arr[pos2];
    arr[pos2] = temp;
}

Answer 3

这是一种使用按位XOR(^)运算符在java中在一行中交换两个变量的方法。

class Swap
{
   public static void main (String[] args)
   {
      int x = 5, y = 10;
      x = x ^ y ^ (y = x);
      System.out.println("New values of x and y are "+ x + ", " + y);
   }
} 

输出：

x 和 y 的新值为 10、5

Answer 4

将此单线用于任何原始数字类，包括double 和float：

a += (b - (b = a));

例如：

double a = 1.41;
double b = 0;
a += (b - (b = a));
System.out.println("a = " + a + ", b = " + b);

输出为a = 0.0, b = 1.41

Answer 5

Java 中没有指针。但是，每个“包含”对象的变量都是对该对象的引用。要拥有输出参数，您必须使用对象。 在你的情况下，整数对象。

因此，您必须创建一个包含整数的对象，然后更改该整数。你不能使用 Integer 类，因为它是不可变的（即它的值不能改变）。

另一种方法是让方法返回一个数组或一对整数。

Answer 6

在这种情况下，有一种使用带有一个元素的数组的快速而肮脏的解决方案：

public void swap(int[] a, int[] b) {
  int temp = a[0];
  a[0] = b[0];
  b[0] = temp;
}

当然，您的代码也必须使用这些数组，这很不方便。如果您想从内部类修改局部最终变量，则数组技巧会更有用：

public void test() {
  final int[] a = int[]{ 42 };  
  new Thread(new Runnable(){ public void run(){ a[0] += 10; }}).start();
  while(a[0] == 42) {
    System.out.println("waiting...");   
  }
  System.out.println(a[0]);   
} 

Answer 7

强大的 IntHolder 呢？我只是喜欢任何名称中带有 omg 的包！

import org.omg.CORBA.IntHolder;

IntHolder a = new IntHolder(p);
IntHolder b = new IntHolder(q);

swap(a, b);

p = a.value;
q = b.value;

void swap(IntHolder a, IntHolder b) {
    int temp = a.value;
    a.value = b.value;
    b.value = temp;
}

Answer 8

片段 1

public int[] swap1(int[] values) {
  if (values == null || values.length != 2)
    throw new IllegalArgumentException("parameter must be an array of size 2");
  int temp = values[0];
  values[0]=values[1];
  values[1]=temp;
  return values;
}

片段 2

public Point swap2(java.awt.Point p) {
  if (p == null)
    throw new NullPointerException();
  int temp = p.x;
  p.x = p.y;
  p.y = temp;
  return p;
}

用法：

int[] values = swap1(new int[]{x,y});
x = values[0];
y = values[1];

Point p = swap2(new Point(x,y));
x = p.x;
y = p.y;

Answer 9

Java 使用 按值传递。无法使用方法交换两个原语或对象。

虽然可以交换整数数组中的两个元素。

Answer 10

你不能在 Java 中使用引用，所以交换函数是不可能的，但你可以在每次使用交换操作时使用以下代码 sn-p：

T t = p
p = q
q = t

其中 T 是 p 和 q 的类型

但是，可以通过重写属性来交换可变对象：

void swap(Point a, Point b) {
  int tx = a.x, ty = a.y;
  a.x = b.x; a.y = b.y;
  b.x = t.x; b.y = t.y;
}

Answer 11

你必须内联。但是你真的不需要在 Java 中进行这种交换。

Answer 12

您的交换函数本质上是在更改两块内存中的值。任何引用这些内存位的东西现在都会得到不同的值。

在 Java 中并没有真正的指针，所以这是行不通的。相反，引用保存在对象上，您只能更改对象内部的内容。如果您需要在两个地方引用一个对象，以便您可以在系统中传递相同的值并让事物对它们的变化做出反应，请尝试使用the repository pattern 或dependency injection 之类的方法。

我们只能猜测您为什么需要在 C 中使用此代码。我能给出的唯一建议是考虑对您想要实现的对象的更改，最好在实际对象上添加一个方法，而不是拉取它们的内部出，并改为调用该方法。如果这对您没有帮助，请尝试发布调用代码，因为我们可能会很好地了解如何以 Java 风格解决实际问题。

Answer 13

Java 是按值传递的。因此，您所说的swap 是不可能的。但是您可以交换两个对象的内容，也可以内联。

Answer 14

您可以使用或不使用临时变量来交换变量。

这是一篇文章，提供了多种方法来交换没有临时变量的数字：

http://topjavatutorial.com/java/java-programs/swap-two-numbers-without-a-temporary-variable-in-java/

Answer 15

您可以轻松地自己编写一个。

给定：

int array[]={1,2};

你会的：

int temp=array[0];
array[0]=array[1];
array[1]=temp;

你就完成了。 3 行代码。

Answer 16

使用 pointer 进行交换在 java 中是不可能的。 不过，您可以通过传递包含两个对象的数组来实现交换。

代码如下：

public class Swap {
    public static void swap(String [] a){
        String temp;
        temp = a[0];
        a[0] = a[1];
        a[1] = temp;
    }
    public static void main(String [] args){
        String [] foo = new String[2];
        foo[0] = "str1";
        foo[1] = "str2";
        swap(foo);
        System.out.println("First value: "+ foo[0]);
        System.out.println("Second value: "+ foo[1]);
    }
}

输出：

First value: str2
Second value: str1

Answer 17

public class swaptemp {
    public static void main(String[] args) {
        String s1="10";
        String s2="20";
        String temp;
        System.out.println(s1);
        System.out.println(s2);

        temp=Integer.toString(Integer.parseInt(s1));
        s1=Integer.toString(Integer.parseInt(s2));
        s2=Integer.toString(Integer.parseInt(temp));

        System.out.println(s1);
        System.out.println(s2);
    }
}

Answer 18

//here is also another answer:
class SwapDemo{
    static int a=1, b=2 ;
    public static void main(String [] args){
        Swap swp = new Swap();
        swp.swaps(x,y);
        System.out.println( " a (was 1)now is " + a + " b (was 2) now is " + b);
    }
}
class Swap{
    void swaps(int c, int d){
            SwapDemo f = new SwapDemo();
            f.a = c;
            f.a = d;
        }
}

Answer 19

  class Swap2Values{
    public static void main(String[] args){
       int a = 20, b = 10;

       //before swaping
       System.out.print("Before Swapping the values of a and b are: a = "+a+", b = "+b);

       //swapping
       a = a + b;
       b = a - b;
       a = a - b;

       //after swapping
      System.out.print("After Swapping the values of a and b are: a = "+a+", b = "+b);
    }
  }