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的唯一方法就是使用单线程。

BTW：如果您的数据恰好是List，更好的交换方式是使用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 []数组进行排序

显然，真正的目标是对一组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]

这是一个简单的辅助函数，可以在一个int数组中交换两个位置：

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类，因为它是不可变的（即它的值不能改变）。

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

Answer 6

强大的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 7

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

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

Answer 8

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

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 9

片段-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 10

您不能在Java中使用引用，因此交换功能是不可能的，但是每次使用交换操作时都可以使用以下代码片段：

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中需要这个代码的原因。我能给出的唯一建议就是考虑你想要实现的对象的变化，最好在实际对象上添加一个方法而不是拉出它们的内部结构。 out，并改为调用该方法。如果这对您没有帮助，请尝试发布调用代码，因为我们可能已经知道如何解决Java风格的真正问题。

Answer 13

Java是按值传递的。所以你所指的swap是不可能的。但是你可以交换两个对象的内容，或者你可以内联它。

Answer 14

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

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

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

Answer 15

使用指针进行交换在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 16

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 17

您可以轻松自己写一个。

下式给出：

int array[]={1,2};

你这样做：

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

你已经完成了。 3行代码。

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

如何在Java中编写基本交换函数

19 个答案:

排序两个整数

对int []数组进行排序