写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。

1. public class tt {
   
2.         public static void main(String[] args) {
   
3.                 int[][] arr = arrs();
   
4.                 for (int i = 0; i < arr.length; i++) {
   
5.                         for (int j = 0; j < arr[i].length; j++) {
   
6.                                 if(arr[i][j]<10)
   
7.                                         System.out.print("0"+arr[i][j]+ " ");
   
8.                                 else
   
9.                                 System.out.print(arr[i][j]+ " ");
   
10.                         }
    
11.                         System.out.println();
    
12.                 }
    
13.                
    
14.                
    
15.                
    
16.         }
    
17. 
    
18.         public static int[][] arrs() {
    
19.         //        System.out.println("请输入方阵行数或列数：");
    
20.         //        Scanner sc=new Scanner(System.in);
    
21.         //        int le=sc.nextInt();// 数组长度
    
22.                 int le=9;
    
23.         //        System.out.println("请检查方阵是否正确");
    
24.                
    
25.                 int arr[][] = new int[le][le];
    
26.                 int x = 0;// 小数组下标，横向
    
27.                 int y = 0;// 数组下标，纵向
    
28.                 int n = 1;// 显示数字
    
29.                
    
30.                 // 螺旋顺序是右》下》左》上》右。。
    
31.                 int c = 0;// 圈数从最外面是第一圈c=0
    
32.                 int t = 1;// 1右2下3左4上
    
33.                 boolean b=true;
    
34. while(b){
    
35.                 while (t == 1 && x < le - c && x >= c) {
    
36.                         arr[y][x++] = n++;
    
37.                         //x++;
    
38.                         //n++;
    
39.                        
    
40.                         if (x == le - c) {
    
41.                                
    
42.                                 t = 2;
    
43.                         }
    
44.                         if (n == le * le+1)
    
45.                                 b=false;
    
46.                 }
    
47.                 x = le - c - 1;
    
48.                 y = c + 1;
    
49.                 while (t == 2 && y > c && y < le - c) {
    
50.                         arr[y++][x] = n++;
    
51.                         //y++;
    
52.                         //n++;
    
53.                         if (y == le - c) {
    
54.                                 t = 3;
    
55.                                
    
56.                         }
    
57.                         if (n == le * le+1)
    
58.                                 b=false;
    
59.                 }
    
60.                 y = le - c - 1;
    
61.                 x = le - c - 2;
    
62.                 while (t == 3 && x < le - c - 1 && x >= c) {
    
63.                         arr[y][x--] = n++;
    
64.                         //n++;
    
65.                         //x--;
    
66.                         if (x < c) {
    
67.                                 t = 4;
    
68.                                
    
69.                         }
    
70.                        
    
71.                         if (n == le * le+1)
    
72.                                 b=false;
    
73.                 }
    
74.                 x = c;
    
75.                 y = le - c - 2;
    
76.                 while (t == 4 && y > c && y < le - c - 1) {
    
77.                         arr[y--][x] = n++;
    
78.                         //y--;
    
79.                         //n++;
    
80.                         if (y == c) {
    
81.                                 t = 1;
    
82.                                 c++;
    
83.                         }
    
84.                         if (n == le * le+1)
    
85.                                 b=false;
    
86.                 }
    
87.                 x = c;
    
88.                 y = c;
    
89.                
    
90.                
    
91.                
    
92. }
    
93.                 return arr;
    
94.         }
    
95.        
    
96. }

复制代码

1. public class text {
   
2. 
   
3.           public static void main(String[] args) {
   
4.           // 根据n创建一个二维数组
   
5.           int n = 5;
   
6.           int[][] arr = new int[n][n];
   
7.           // 调用数组赋值的方法
   
8.           method(arr);
   
9.           // 将数组遍历出来
   
10.           for (int i = 0; i < arr.length; i++) {
    
11.                   for (int j = 0; j < arr.length; j++) {
    
12.                           System.out.print(arr[i][j] + "\t");
    
13.                   }
    
14.                   System.out.println("\n");
    
15.           }
    
16. 
    
17.   }
    
18. 
    
19.   // 二维数组赋值方法
    
20.   public static void method(int[][] arr) {
    
21.           // 创建数组的两个索引变量
    
22.           int i = 0;
    
23.           int j = 0;
    
24.           // 通过 max 和min控制索引i，j的变化
    
25.           int max = arr.length - 1;
    
26.           int min = 0;
    
27.           // 所需要赋的值
    
28.           int num = 1;
    
29. 
    
30.           while (min <= max) {
    
31.                   // 1、i不变j++ 向右
    
32.                   while (j < max) {
    
33.                           arr[i][j++] = num++;
    
34.                   }
    
35.                   // 2、j不变i++ 向下
    
36.                   while (i < max) {
    
37.                           arr[i++][j] = num++;
    
38.                   }
    
39.                   // 3、i不变j-- 向左
    
40.                   while (j > min) {
    
41.                           arr[i][j--] = num++;
    
42.                   }
    
43.                   // 4、j不变i-- 向上
    
44.                   while (i > min) {
    
45.                           arr[i--][j] = num++;
    
46.                   }
    
47.                   // 由于可能在n为奇数的时候无法为中心那个数赋值所以要补上这个数的赋值
    
48.                   if (min == max) {
    
49.                           arr[i][j] = num;
    
50.                   }
    
51.                   max--;
    
52.                   min++;
    
53.                   // 循环一圈又开始想有赋值j++
    
54.                   j++;
    
55.                   // 由于向上的时候最后一次赋值i多减了一次所以每次外循环都要将i补回来
    
56.                   i++;
    
57.           }
    
58.   }
    
59. }
    

复制代码

这个是别人写的属于简单方法，不过大体思路是一样的都是，从外面一圈圈循环先给数组赋值，这个每一圈赋值的长度都一样（好看懂），上面的我感觉你要是看懂了应该理解的会更深点