package String.lianxi;

public class ClassDemo2 {

        /**
         * 将一个字符串按指定位置进行反转 如“abcdef”,从2——5反转 结果是：abfedc
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                String s = "abcdef";
                System.out.println("源串：" + s);
                System.out.println("反转后：" + reverseString(s, 2, 5));

        }

        private static String reverseString(String s, int i, int j) {
                // TODO Auto-generated method stub
                char[] ch = s.toCharArray();// 字符串变数组;
                reverse(ch, i, j);// 反转数组；调用reverse()方法，5和4换位置，2和3换位置；
                return new String(ch);// 将数组变成字符串;
                                /*我感觉这应该这样写，但是错的为什么？
                    char[] chs =reverse(ch, i, j);返回类型是数组，我们用数组接收
                               return new String(chs); 把返回的数组转成字符串*/
        }

        private static String reverse(char[] ch, int x, int y) {

                for (int start = x, end = y; start < end; start++, end--) {
                        swap(ch, start, end);
                }
                return null;// 这为什么返回空值呢？按道理应该返回你换完位置的数组？
                                  应该是return ch;但结果是错的？为什么？
                // retrun ch;????
        }

        private static void swap(char[] ch, int x, int y) {
                char temp = ch[x];
                ch[x] = ch[y];
                ch[y] = temp;

        }

}

1. private static String reverse(char[] ch, int x, int y) {//这里ch指向内存里那块数组的空间，
   
2. 
   
3.     for (int start = x, end = y; start < end; start++, end--) {
   
4.             swap(ch, start, end);
   
5.     }
   
6.     return null;//因为在ch指向的内存中的数组中的数据已经被改变了，所以这里不用返回ch这个引用了，reverString里的ch仍指向这那个数组，
   
7. }
   
8. private static void swap(char[] ch, int x, int y) {//这里的ch同样还是指向内存里数组的地址
   
9.     char temp = ch[x];
   
10.     ch[x] = ch[y];//这里真正把内存中数组中的值改变了。
    
11.     ch[y] = temp;
    
12. }

复制代码

在整个过程中，内存中就一个数组，只要通过它的一个引用把它修改了，其他引用获得的数组数据也会是修改后的。这里传递的ch是引用，指向内存里里的那个数组，若有多个引用指向同一块内存空间，其中一个引用把空间里的数据改了，其他引用获得的数据也是最新的。

参数传递的方式有：值传递和地址引用传递。值传递时，实参把其值传给形参，形参的变化不影响实参，因为它们是两个不同的变量，在内存中占有不同的存放位置。
地址引用传递时：传递的是实参在内存中的存放地址，让形参也共享实参地址里的内容。形参的变化影响着实参。既实参、形参在内存中的位置是一样的。
这里01.private static String reverse(char[] ch, int x, int y) 和08.private static void swap(char[] ch, int x, int y)中的char[] 地址引用的传递，把实际的数组传入之后，就会按照方法的功能来改变实际数组了。

reverse方法返回的是是字符串啊，不是数组啊，希望是你注释的时候 搞错了。我修改了一下可以了，不知道是不是楼主想要的：

1. 
   
2. public class ClassDemo2 {
   
3. 
   
4.         /**
   
5.           * 将一个字符串按指定位置进行反转 如“abcdef”,从2——5反转 结果是：abfedc
   
6.           */
   
7.          public static void main(String[] args) {
   
8.                  // TODO Auto-generated method stub
   
9.                  String s = "abcdef";
   
10.                  System.out.println("源串：" + s);
    
11.                  System.out.println("反转后：" + reverseString(s, 2, 5));
    
12. 
    
13.         }
    
14. 
    
15.         private static String reverseString(String s, int i, int j) {
    
16.                  
    
17.                  char[] ch = s.toCharArray();// 字符串变数组;
    
18.                  //reverse(ch, i, j);// 反转数组；调用reverse()方法，5和4换位置，2和3换位置；
    
19.                  //return new String(ch);// 将数组变成字符串;
    
20.                                  
    
21.                      String ch1 =reverse(ch, i, j);         
    
22.                      return ch1;
    
23.          }
    
24. 
    
25.         private static String reverse(char[] ch, int x, int y) {
    
26. 
    
27.                 for (int start = x, end = y; start < end; start++, end--) {
    
28.                          swap(ch, start, end);
    
29.                  }                  
    
30.                 return new String(ch);
    
31.          }
    
32. 
    
33.         private static void swap(char[] ch, int x, int y) {
    
34.                  char temp = ch[x];
    
35.                  ch[x] = ch[y];
    
36.                  ch[y] = temp;
    
37. 
    
38.         }
    
39. 
    
40. }
    

复制代码

何拴绪 发表于 2012-6-9 10:36
reverse方法返回的是是字符串啊，不是数组啊，希望是你注释的时候 搞错了。我修改了一下可以了，不知道是不 ...

知道了
package String.lianxi;

public class ClassDemo2 {

        /**
         * 将一个字符串按指定位置进行反转 如“abcdef”,从2——5反转 结果是：abfedc
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                String s = "abcdef";
                System.out.println("源串：" + s);
                System.out.println("反转后：" + reverseString(s, 2, 5));

        }

        private static String reverseString(String s, int i, int j) {
                // TODO Auto-generated method stub
                char[] ch = s.toCharArray();// 字符串变数组;
                String s1=reverse(ch, i, j);// 反转数组；调用reverse()方法，5和4换位置，2和3换位置；
                return s1;S
                //return new String(ch);// 将数组变成字符串;
        }

        private static String reverse(char[] ch, int x, int y) {

                for (int start = x, end = y; start < end; start++, end--) {
                        swap(ch, start, end);
                }
                //return null;// 这为什么返回空值呢？按道理应该返回你换完位置的数组？应该是return ch;但结果是错的？为什么？
                // retrun ch;????
                return new String(ch);
        }

        private static void swap(char[] ch, int x, int y) {
                char temp = ch[x];
                ch[x] = ch[y];
                ch[y] = temp;

        }

}