如何在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
使用这个一行代码包括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
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); } }
