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

我是新来的Java。 如何编写下面的C代码的Java等价物。

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

这里有一个窍门:

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

sorting两个整数

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

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

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

您可以使用各种容器对象(如集合和数组或具有int属性的自定义对象)来完成此操作,但不能与基元和其包装(因为它们都是不可变的)。 但是,我猜,让AtomInteger成为一条线的唯一方法就是AtomicInteger。

顺便说一句:如果你的数据碰巧是一个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. 

sorting一个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; } 

下面是一个使用按位异或(^)运算符 在一行中交换两个variables的方法。

 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

使用这个一行代码包括doublefloat在内的任何原始数字类:

 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

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

所以你将不得不做一个包含一个整数的对象,并更改该整数。 你不能使用Integer类,因为它是不可变的(即它的值不能改变)。

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

片段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 = px; px = py; py = temp; return p; } 

用法:

 int[] values = swap1(new int[]{x,y}); x = values[0]; y = values[1]; Point p = swap2(new Point(x,y)); x = px; y = py; 

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

尽pipe可以交换整数数组中的两个元素。

您不能在Java中使用引用,所以交换function是不可能的,但是每次使用交换操作时都可以使用下面的代码片段:

 T t = p p = q q = t 

其中T是p和q的types

但是,通过重写属性可能会交换可变对象:

 void swap(Point a, Point b) { int tx = ax, ty = ay; ax = bx; ay = by; bx = tx; by = ty; } 

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

在这种情况下,使用具有一个元素的数组有一个快速和肮脏的解决scheme:

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

当然你的代码也必须和这些数组一起工作,这很不方便。 数组技巧更有用,如果你想修改一个内部类的本地最终variables:

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

你的交换function本质上改变了两个内存中的值。 任何引用这些内存位的东西现在都会得到不同的值。

在Java中没有真正的指针,所以这是行不通的。 相反,引用是在对象上进行的,你只能改变对象内的东西。 如果你需要在两个地方引用一个对象,那么你可以在系统周围传递相同的值,并让事情对它们做出反应,像存储库模式或dependency injection那样 。

我们只能猜测为什么你需要C代码。唯一的build议是可以考虑对你想实现的对象的修改,最好在实际的对象上添加一个方法,而不是把内部的内部抽出来,调用该方法。 如果这对你没有帮助,请尝试发布调用代码,因为我们可能对如何解决真正的Java风格问题有一个很好的想法。

Java是通过价值。 所以在这个意义上的swap是不可能的。 但是你可以交换两个对象的内容,或者你可以内联。

那强大的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; } 

您可以使用或不使用临时variables交换variables。

这里是一个文章,提供了多个方法来交换数字没有临时variables:

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

你可以自己写一个。

给定:

 int array[]={1,2}; 

你做:

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

你完成了。 3行代码。

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

在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 
 //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(); fa = c; fa = d; } } 
  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); } }