1. package lesson4;
   
2. /*
   
3. 二维数组的行列互换直接在方法中实现产生一个新二维数组没有问题，为什么在方法中实现时返回的二维数组史记录了最后一次交换的结果 。
   
4. */
   
5. public class Arrayhlhuhuan {
   
6. 
   
7.         /**
   
8.          * 二维数组的行列互换
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    
12.                 sop(arr);
    
13.                 System.out.println("---------------------------------------------");
    
14.                 int [][]newarrs=huan(arr);
    
15.                 sop(newarrs);
    
16.         }
    
17. 
    
18.         private static void sop(int[][] arr) {
    
19.                 for (int i = 0; i < arr.length; i++) {
    
20.                         for (int j = 0; j < arr.length; j++) {
    
21.                                 System.out.print(arr[j] + "\t");
    
22.                         }
    
23.                         System.out.println();
    
24.                 }
    
25.                
    
26.         }
    
27. 
    
28.         private static int[][] huan(int[][] arr) {
    
29.                 int row = arr.length;//行数
    
30.                 int low = arr[0].length;//列数
    
31.                 int[][] newarrs = new int[low][row];//新建数组
    
32.                 int[] newarr = new int[row];//一维数组，容量为原数组的行数
    
33.                 for (int i = 0; i < low; i++) {//列循环
    
34.                         for (int j = 0; j < row; j++) {//行循环
    
35.                                 int data = arr[j];
    
36.                                 newarr[j] = data;//原数组每一列装入一维数组内。
    
37. 
    
38.                         }
    
39.                         newarrs=newarr;//一维数组作为一个元素放入二维数组内。
    
40.                         sop1(newarrs);
    
41.                         System.out.println();//测试二维数组装入的元数。
    
42. 
    
43.                 }
    
44.                 System.out.println("---------------------");
    
45.                 for (int i = 0; i < newarrs.length; i++) {
    
46.                         sop1(newarrs);
    
47.                 }
    
48.                 System.out.println("---------------------");
    
49.                 return newarrs; //返回交换后的数组
    
50.         }
    
51. 
    
52.         private static void sop1(int[] newarr) {
    
53.                 for (int i = 0; i < newarr.length; i++) {
    
54.                         System.out.print(newarr+"\t");
    
55.                 }
    
56.         }
    
57. 
    
58. }
    

复制代码

亲，如问题已解决请将分类的“未解决”改为“已解决”。 以后的问题贴也要及时更改分类哦~

行列互换为何会搞得这么麻烦，不就是一个a[i][j]换成a[j][i]么？

问题出现在你这一句：

1. newarrs[i]=newarr;//一维数组作为一个元素放入二维数组内。

复制代码

数组是引用类型啊！！！
当你的newarr[0]=newarr的时候，你的newarrs[0]这个一维数组引用指向了newarr，下一次当你的newarr改变时，newarrs[0]也就变了。
同理，你后面的newarrs[1]和newarrs[2]这两个一维数组都指向了newarr，那么最终结果就是三行都变成了：369
只要将这个过程改成单独的数组内元素赋值就可以了。注意34行和35行

1. public class Arrayhlhuhuan {
   
2.     /**
   
3.      * 二维数组的行列互换
   
4.      */
   
5.     public static void main(String[] args) {
   
6.             int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
   
7.             sop(arr);
   
8.             System.out.println("---------------------------------------------");
   
9.             int [][]newarrs=huan(arr);
   
10.             sop(newarrs);
    
11.     }
    
12. 
    
13.     private static void sop(int[][] arr) {
    
14.             for (int i = 0; i < arr.length; i++) {
    
15.                     for (int j = 0; j < arr[i].length; j++) {
    
16.                             System.out.print(arr[i][j] + "\t");
    
17.                     }
    
18.                     System.out.println();
    
19.             }
    
20.             
    
21.     }
    
22. 
    
23.     private static int[][] huan(int[][] arr) {
    
24.             int row = arr.length;//行数
    
25.             int low = arr[0].length;//列数
    
26.             int[][] newarrs = new int[low][row];//新建数组
    
27.             int[] newarr = new int[row];//一维数组，容量为原数组的行数
    
28.             for (int i = 0; i < low; i++) {//列循环
    
29.                     for (int j = 0; j < row; j++) {//行循环
    
30.                             int data = arr[j][i];
    
31.                             newarr[j] = data;//原数组每一列装入一维数组内。
    
32. 
    
33.                     }
    
34.                     //newarrs[i]=newarr;//一维数组作为一个元素放入二维数组内。
    
35.                     Tool.change(newarrs[i], newarr);
    
36.                     sop1(newarrs[i]);
    
37.                     System.out.println();//测试二维数组装入的元数。
    
38. 
    
39.             }
    
40.             System.out.println("---------------------");
    
41.             for (int i = 0; i < newarrs.length; i++) {
    
42.                     sop1(newarrs[i]);
    
43.             }
    
44.             System.out.println("---------------------");
    
45.             return newarrs; //返回交换后的数组
    
46.     }
    
47. 
    
48.     private static void sop1(int[] newarr) {
    
49.             for (int i = 0; i < newarr.length; i++) {
    
50.                     System.out.print(newarr[i]+"\t");
    
51.             }
    
52.     }
    
53. }
    
54. 
    
55. class Tool
    
56. {
    
57.         public static void change(int[] a,int[] b)
    
58.         {
    
59.                 for(int i=0;i<b.length;i++)
    
60.                 {
    
61.                         a[i] = b[i];
    
62.                 }
    
63.         }
    
64. }

复制代码

你这个太复杂了，我给你简单的核心代码在这(限定二维数组是行列相等)，主要是异或操作，异或操作是交换两个整形的最优方法，不需要开辟空间，效率也是比较好的。

1. for（int i = 0; i <n; i++）//n代表整数
   
2.     for(int j=0 ; j <i; j++)
   
3.         new[i][j]^=new[j][i];
   
4.         new[j][i]^=new[i][j];
   
5.         new[i][j]^=new[j][i];

复制代码

package lesson5;

public class xt4 {

       
        public static void main(String[] args) {
                int [][]arr={{1,2,3},{4,5,6},{7,8,9}};
                System.out.println("原数组的内容：");
                printArray(arr);
               
                int [][]newarr=huanhl(arr);
                System.out.println("行列交换后的数组：");
                printArray(newarr);
        }

        private static int[][] huanhl(int[][] arr) {
                int x=arr.length;
                int y=arr[0].length;
                int newarr[][]=new int [y][x];
               
                for (int i=0;i<y;i++){
                        for (int j=0;j<x;j++){
                                int num=arr[j][i];//取每一列，行变，列不变。
                                newarr[i][j]=num;//行不变，列变，装入行。
                        }
                }
                return newarr;
        }

        private static void printArray(int[][] arr) {
                /*for (int i=0;i<arr.length;i++){
                        for (int j=0;j<arr[i].length;j++){
                                System.out.print(arr[i][j]+"\t");
                        }
                        System.out.println();
                }*/
               
                for (int[] is : arr) {
                        for (int  i : is) {
                                System.out.print(i+"\t");
                        }
                        System.out.println();
                }
        }

}
上回蒙圈了，终于解快