求解：写一个Java函数，交换两个字符串的值

Question

有两个字符串String s1="s1"; String s2="s2";如何通过一个函数调用来交换他们的值？
求各位大侠帮个忙，谢谢！

Answer 1

如果两个String作为函数的参数的话，是不能达到效果的

Answer 2

public void swap(String s1,String s2){ 
String temp=s1; 
s1=s2; 
s2=temp; 
}
首先：可以肯定的讲，这种对象交换，你是实现不了的。
如果一定要这样交换的话，必须借助另外一个对象。
像下面这样class Sunflower {
 public static String str1;
 public static String str2;
}public class Demo {
 public static void main(String[] args) throws Exception {
  Sunflower s = new Sunflower();
  s.str1 = "111";
  s.str2 = "222";
  change(s);
  System.out.println(s.str1);
  System.out.println(s.str2);
 } public static void change(Sunflower s1) {
  String temp = s1.str1;
  s1.str1 = s1.str2;
  s1.str2 = temp;
 }
}这样才可以成功交换！
如果你对 值、引用、对象有一定了解的话，我在这里可以多讲一些。
值这里就不讲了：
主要：对象,引用
对象 != 引用
如果你明白这一点，可以继续看下去，反之只要记住上面给你的交换方法，下次机械的用就可以了。对象：一个对象可以被很多引用关联引用: 一个引用只可以关联一个对象
Object obj1;
Object obj2;
Object obj3;
这里我创建了三个引用，没有创建对象
Sunflower sunflower = new Sunflower();
这里的sunflower也是一个引用
而new Sunflower();这个在内存中创建了一个对象。它被sunflower引用关联，就像一个对象句柄，这个句柄可以操纵那个对象。
引用是什么？
引用也是一个值，只不过它的值是记录其关联对象的地址信息的，
还拿你的方法作例子：
public void swap(String s1,String s2){ 
只要是参数在方法内使用时，都会产生参数的副本的。
记住这一点，无论java，C#,C,C++。
1> String temp=s1; 
1【我们首先看这里发生了什么。
这里的s1只是一个副本,是实际s1引用的一个副本
副本s1和实际s1具有相同的值。那就是对传进来对象的关联。同理s2也是如此】
s1=s2; 
s2=temp; 
//所以当这样简单的交换的时候，你是交换的副本而已
//虽然副本s1和实际s1指向同一个对象。
//但是你交换的是副本
//
}
//另外给你补充一点知识
//String 类型：
String str="SUNFLOWER"; 
str.toLowerCase()
System.out.println(str);
结果是什么：还是SunflOwer。为什么呢
因为你调用String类型的toLowerCase()之类的方法时
会从新开辟内存，用来存放转换后的对象“sunflower”
str引用还是关联"SUNFLOWER"的内存,你并没有把str从新指向"sunflower"的内存
如果这样
str=str.toLowerCase();
这样就是你理想的结果了
还回到讨论。
所以上面你改成
public void swap(String s1,String s2){ 
 1:s1.toLowerCase(); 
 //1 虽然这里的副本s1和实际s1指向同一对象，
 //但是s1.toLowerCase(); 创建了一个新对象，
 //并没有改变原来对象什么
 或者这样
 2：s1=s1.toLowerCase();
 //这里你只是改变了副本引用值，和实际引用没关系
}
下面解释我的方法
public static void change(Sunflower s1) {
  String temp = s1.str1;
  s1.str1 = s1.str2;
  s1.str2 = temp;
              方法内的s1是原引用的一个副本
               他们有共同的值，所以操纵同一对象
    假如Sunflower sunflower new Sunflower();
   假设其所创建的对象为sun。
    sun的实际引用为sunflower
      假设sunflower在方法内的副本为copy
      因为sunflower引用和copy引用都具有相同的关联
      对象sun
      当sunflower.str1或sun.str1改变的时候，
      他们操纵的是同一个对象。
      这样就可以交换了        
}
http://zhidao.baidu.com/question/54625888.html

Answer 3

抱歉，String 类的对象值一旦设定就不能在改变！用StringBuffer吧

Answer 4

楼上正解，String类型的值一旦设定，只能增加长度，不可能改变内容了。

Answer 5

我也同意楼上，但是我的eclipse不同意，呵呵

Answer 6

private String s1 = "s1";
private String s2 = "s2";

private void swap(){
String tmp = s1;
s1 = s2;
s2 = tmp;
System.out.println("s1===="+s1);
System.out.println("s2===="+s2);
}

Answer 7

很简单的, 只要用反射就成了import java.lang.reflect.*;public class SwapStr
{
public static void swap(String str1, String str2)
{
try{
Object temp; Field fv = String.class.getDeclaredField("value");
Field fo = String.class.getDeclaredField("offset");
Field fc = String.class.getDeclaredField("count");
Field fh = String.class.getDeclaredField("hash"); fv.setAccessible(true);
fo.setAccessible(true);
fc.setAccessible(true);
fh.setAccessible(true); temp = fv.get(str1);
fv.set(str1, fv.get(str2));
fv.set(str2, temp); temp = fo.get(str1);
fo.set(str1, fo.get(str2));
fo.set(str2, temp); temp = fc.get(str1);
fc.set(str1, fc.get(str2));
fc.set(str2, temp); fh.setInt(str1, 0);
fh.setInt(str2, 0);
}catch(Exception e){
e.printStackTrace();
}
} public static void main(String[] args)
{
String str1 = "hello";
String str2 = "world"; swap(str1, str2); System.out.println(str1 + " " + str2);
}
}

Answer 8

楼上有说：
“
楼上正解，String类型的值一旦设定，只能增加长度，不可能改变内容了。 
我也同意楼上，但是我的eclipse不同意，呵呵 
”
纠正下错误！String一旦设定值，就不能再做任何改变，包括长度改变和内容改变！
在Eclipse中可以，是因为Java给我们提供了一个String pool ，所有改变后的String都在pool中。而你们看到的改变实际上就是另一个String的产生！ 

Answer 9

对Ruby来说，就是这样的：a和b是两个字符串。a, b = b, a

Answer 10

直接中间变量交换不就行了嘛,如果要写个函数,那也行,不过,觉得好像没必要吧~ 如果考虑到长度不同的,那就要用StringBuffer或者StringBuilder