java中交换两个数的值

现有一个方法
public void swap(int x,inty)
在main方法中调用
swap(a,b);//a、b均为int型
调用完之后要求交换两个数的值
我们知道，这个在C/C++是十分简单的函数，但在java中该如何实现呢？ 

82 个解决方案

#1

这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

#2

引用 1 楼 lujun0527 的回复:

这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

这个能交换吗？

#3

Java如果是作为参数传递进来的，那么实现不了这个功能

#4

1楼的肯定是不可以的

#5

java基本数据类型作为参数 只能传值 对象只能传引用
不像c/c++那样
public void swap(int x,inty) 这个只不能改变x 、y的值的 一旦离开此个方法 x 、y照样是原来的值 改变不了

#6

引用 2 楼 hudie1234567 的回复:

引用 1 楼 lujun0527 的回复:
这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

这个能交换吗？

这个离开作用域范围 也就是函数  照样是实现不了两个值的交换  试试就知道咯

#7

这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

#8

一楼的答案是错误的。在java中，基本类型的变量是传递的值，不是传递的引用。

#9

public static double x,y; 
 public static void main(String[] args) 
{ 
  x = 3.0; 
  y = 4.0; 
  swap(x,y); 
  System.out.print(x+" "+y); 
 } 
  public void swap(int a,int b)
 
 { 
   x=b; 
   y=a; 
  } 

#10

引用 8 楼 liyu1006 的回复:

一楼的答案是错误的。在java中，基本类型的变量是传递的值，不是传递的引用。

9楼是正解，无论值传递还是引用传递，在java中都不能实现一楼的交换

#11

菜鸟，来受叫了

#12

引用 1 楼 lujun0527 的回复:

这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

。。。。。实现不了的

#13

写一个类封装，或者返回数组

#14

引用 9 楼 xuanfenglover 的回复:

public static double x,y; 
 public static void main(String[] args) 
{ 
  x = 3.0; 
  y = 4.0; 
  swap(x,y); 
  System.out.print(x+" "+y); 
 } 
  public void swap(int a,int b)
 
 { 
  x=b; 
……

呃……话说能不能不用全局变量，我知道一楼的肯定不行，这么简单的话我就不会来问了

#15

典型的算法。。以后交换都是这样算。
int temp 
temp = x;
x = y;
y = temp;
两个书就交换了。
 

#16

用函数交换不了

#17

void swap(int[] data,int index1,int index2){
   int tmp = data[index1];
   data[index1] = data[index2];
   data[index2] = tmp;
}

#18

引用 15 楼 skill_cheng 的回复:

典型的算法。。以后交换都是这样算。
int temp 
temp = x;
x = y;
y = temp;
两个书就交换了。

有那么简单吗？x、y是形参，交换之后跟a、b有何关系？

#19

引用 17 楼 huntor 的回复:

Java code
void swap(int[] data,int index1,int index2){
   int tmp = data[index1];
   data[index1] = data[index2];
   data[index2] = tmp;
}

如果我定义死了swap(int x,int y)呢？现在我要交换的是两个int型的变量，不是数组里的变量，更不能传下标

#20

package com.csdn;
public class Test01 {

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

    sawp(a,b);
    System.out.println("a="+a);
    System.out.println("b="+b);


}
public static void sawp(int x,int y){
a=y;
b=x;
}

}



用函数 java交换不了

#21

楼上的都说的很对，我也就凑个热闹。

#22

引用 19 楼 mweibiao 的回复:

如果我定义死了swap(int x,int y)呢？现在我要交换的是两个in……

这样定死了c和c++怎么才能实现这功能？

#23

JAVA中不是有一个swap的多态算法吗？好像还可以用Collections类的shuffle这个多态算法来实现吧。

#24

引用 22 楼 zangxt 的回复:

引用 19 楼 mweibiao 的回复:
如果我定义死了swap(int x,int y)呢？现在我要交换的是两个in……

这样定死了c和c++怎么才能实现这功能？

我的意思是参数的个数定死了，参数的内容必须与x、y相关

#25

如果你定义死了，在C+里的实现是很简单的只要传指针就可以了swap(int *i,int*j)，函数必须声明成这个样子，如果用java，那只有使用对象了，因为函数中的对象参数使用的是引用，这样估计应该可以调换，自己声明的对象应该一定可以的，所以不能用int可以尝试用下Integer试试。成不成希望高手多指教。

#26

Java中，把这两个数xy,组成数组，然后交换返回。

#27

好像没有直接的方法

#28

引用 25 楼 likefedor 的回复:

如果你定义死了，在C+里的实现是很简单的只要传指针就可以了swap(int *i,int*j)，函数必须声明成这个样子，如果用java，那只有使用对象了，因为函数中的对象参数使用的是引用，这样估计应该可以调换，自己声明的对象应该一定可以的，所以不能用int可以尝试用下Integer试试。成不成希望高手多指教。

自己定义的对象就一定可以吗？它传递的是引用的值，不是对象本身。

#29

import java.util.concurrent.atomic.*;
public class Main{
	static void swap(AtomicReference<Integer> a, AtomicReference<Integer> b) {
	    Integer c = a.get();
	    a.set(b.get());
	    b.set(c);
	}
	public static void main(String[] args) {
	    AtomicReference<Integer> a = new AtomicReference<Integer>(28);
	    AtomicReference<Integer> b = new AtomicReference<Integer>(30);
	    System.out.println("a = " + a);
	    System.out.println("b = " + b);
	    swap(a, b);
	    System.out.println("a = " + a);
	    System.out.println("b = " + b);
	}
}

a = 28
b = 30
a = 30
b = 28

#30

在main里调用函数的方法是不行的，交换代码直接写在main里还差不多。

而且我觉得你既然用java写，就应该体现面向对象
把这些封装成一个类比较好，x,y作为类的成员变量，再通过成员方法进行交换。。

#31

翻翻我的帖子，里面有详解

#32

public swap(object x,object y)
{
  object tmp=y;
  y=x;
  x=tmp;
}

不知道这样行不行,利用int等值类型的自动装箱拆箱...

#33

自己写一个分装类吧，传封装类的引用就行了

#34

引用 1 楼 lujun0527 的回复:

这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

java 不是c/C++，不能这样交换的
就算是C/C++，这样写也是交换不了的 

#35

在 java 中要达到楼主的目的很难，当然各种特殊情况的办法也是有的，不过正因为对被交换的两个数据有特殊要求，所以就失去了一般性。

比如情况一：把被交换的两个变量设置成类的静态变量
public class Test{
    public static int a;
    public static int b;
    //......
    public void swap(){
        int tmp = a;
        a = b;
        b = tmp;
    }
}
但是这样写，要求变量 a 和 b 是类的静态成员变量。并且这个方法只能在 Test 类中使用，如果有类似的需求，比如 Test1 中也有两个静态成员变量，a1, b1，那么这个 swap 就只能在 Test1 类中再重写一次。




情况二：被交换的是一个类的两个成员变量
这种情况比前一种情况更有普遍性，但是它还是只限于类成员变量，这时可以使用反射

// 定义一个交换器
class SwapUtil{
    public static boolean swapInt(Object obj, String field1, String field2){
        try{
            Class cls = obj.getClass();
            
            java.lang.reflect.Field f1 = cls.getDeclaredField(field1);
            f1.setAccessible(true);
             
            java.lang.reflect.Field f2 = cls.getDeclaredField(field2);
            f2.setAccessible(true);
            
            int a = f1.getInt(obj);
            int b = f2.getInt(obj);
            
            f1.setInt(obj, b);
            f2.setInt(obj, a);
            
            return true;
        }catch(Throwable ex){
            return false;
        }
    }
}

// 被设置的类 
class TestSwaper{
    private int inta = 10;
    private int intb = 20;
    
    public void print(){
        System.out.println("inta = " + inta + ", intb = " + intb);
    }
}


public class Test{
    public static void main(String[] args){
        TestSwaper testObj = new TestSwaper();
        System.out.println("交换前：");
        testObj.print();
        
        boolean swapResult = SwapUtil.swapInt(testObj, "inta", "intb");
        
        System.out.println("交换" + (swapResult ? "成功" : "失败"));
        
        System.out.println("交换后：");
        testObj.print();
    }
}

这种情况的适应性更大些，并且可以交换私有成员变量，但是前提是调用时必须知道被交换的两个类成员变量的变量名




而对于局部成员变量，除非你是把数据放到数组或者再封装到类里，否则是无法进行交换的：
class SwapUtil{
    public static boolean swapInt(int[] array, int idx1, int idx2){
        int a, b;
        int aOK = false, bOK = false;
        try{
            int a = array[idx1];
            aOK = true;
            int b = array[idx2];
            bOK = true;
            
            int tmp = array[idx1];
            array[idx1] = array[idx2];
            array[idx2] = tmp;
        }catch(ArrayIndexOutOfBoundException ex){
            // 如果交换出现异常，则将数组数据还原
            if(aOK)
                array[idx1] = a;
            if(bOK)
                array[idx2] = b;
            return false;
        }
    }
}

public class Test{
    private static void printArray(int[] array){
        String pre = "";
        for(int a : array){
            System.out.println(pre + a);
            pre = ", ";
        }
    }
    public static void main(String[] args){
        int[] intArray = new int[]{1, 2, 3, 4, 5, 6, 7};
        
        System.out.println("交换前：");
        printArray(intArray);
        
        // 交换数组中的第  3，5 个元素
         SwapUtil.swapInt(intArray, 3, 5);
        
        System.out.println("交换后：");
        printArray(intArray);
    }
}

#36

还是值传递的问题。帖子很多查查看。

#37

引用 1 楼 lujun0527 的回复:

这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

交换不了 =。= 

#38

private int x;
private int y;

public void swap(int x,int y){

   this.x = y;
   this.y = x;
   
}

#39

引用 38 楼 angrykobe 的回复:

Java code


private int x;
private int y;

public void swap(int x,int y){

   this.x = y;
   this.y = x;
   
}

办法有很多，但每种办法都对被交换的数据有一定的要求，你的这个办法里，要求被交换的是类的两个成员变量，适应性不广

其实这是java语言的局限性，java 没有指针，所以无法很好地满足楼主的需求

#40

Java中方法的参数都是值传递。 只有对象才是引用传递。
Interger对象在值小于127时也会自动转型为基本类型。值太小也传不了

可以用Stringbuffer来做引用传递(不建议使用)，或者返回数组。

至于方法里面，常规都是借助临时变量吧。

#41

1.不用临时变量有两种方法
public void swap(int a,int b) {

a=a+b;
b=a-b;
a=a-b;

}
public void swap(int a,int b){
a=a+b;
b=a^b;
a=a^b;
}
2.用临时变量的方法
public void swap(int a,int b) {

int temp=a;
a=b;
b=temp;

}

#42

你这种想要实现个人觉得要么自己写个封装好些，但是像实现你这样的意义好像不大啊

#43

mark啊！！

#44

引用 42 楼 sl346571110 的回复:

你这种想要实现个人觉得要么自己写个封装好些，但是像实现你这样的意义好像不大啊

趁早打消这个念头吧
java 没有指针，不可能实现灵活的数据交换，封装只能针对特殊情况

#45

写返回值吧

#46

引用 1 楼 lujun0527 的回复:

这种是不借助临时变量的方法：
public void swap(int x,inty) {

x=x+y;
y=x-y;
x=x-y;

}
2.借助临时变量的方法
public void swap(int x,inty) {

int temp=x;
x=y;
y=temp;

}

使用返回值更合理

#47

使用返回值是不错的选择

#48

不是有专门的方法啊

#49

同学们好，函数的传递有两种，值传递和引用传递，
这道题是引用传递的典型题，应该这样写
private static void swap(ref int num1,ref int num2){
int temp;
temp=num1;
num1=num2;
num2=temp;}
这样我们就可以用了，
int num1=1,num2=2;
Swap(ref num1,ref num2);

#50

借助临时变量的方法
int t = x + y;
x = t - x;
y = t - y;
或者
int c=x;
x=y;
y=c;
System.out.println ( x + "," + y );