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

1        2        3        4
12        13        14        5
11        16        15        6
10        9        8        7
?

class PrintArray{
        public static void main(String [] args){
                int [][] arr = {{1,2,3,4,},{12,13,14,5},{11,16,15,6},{10,9,8,7}};
                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();
                }
        }
}

本人新人，没有经过专业的培训，只是在慕课网上看了前两季入门视频，编写了下边的代码，有很多粗陋之处：有什么改进之处，请指出
package luntan1;

import java.util.Scanner;

public class dayinfangxingxunhuanshuzu {
/**
* 打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
*
*  1        2       3       4
*  12       13      14      5
*  11       16      15      6
*  10       9       8       7
*  打印思路
*  由外到内一圈一圈的给数组每个元素赋值
*  需要知道圈数和每一圈的每行个数
*  由圈数和个数定位每个元素的位置
*/
/**
* main方法
* 输入等长二维数组长度
* 调用builder（）方法
* 调用打印方法
*/
public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.print("请输入等长二维数组的长度");
        int i=input.nextInt();
        dayinfangxingxunhuanshuzu it=new dayinfangxingxunhuanshuzu();
        int[][] sz=it.builder(i);
        it.printer(sz);
}
       
/**
* 创建生成数组的方法
*/
        public int[][] builder(int length){
                //创建并初始化数组
                int[][] arr=new int[length][length];
                //计算圈数
                int qs1;
                if(length%2==0)
                        qs1=length/2;
                else
                        qs1=(length+1)/2;
                //定义一变量z=1 2 3 4....用以盛放元素的值
                int z=1;
                //开始给每一圈赋值
                for(int qs=1;qs<=qs1;qs++){
                        //获取本圈元素个数
                        int gs=length-qs*2+2;
                        //对本圈上边赋值
                        for(int i=0;i<gs;i++){
                                arr[qs-1][(qs-1)+i]=z;
                                z++;
                        }
                        //对本圈右边赋值
                        for(int i=0;i<gs-1;i++){
                                arr[(qs+i)][length-qs]=z;
                                z++;
                        }
                        //对本圈下边赋值
                        for(int i=0;i<gs-1;i++){
                                arr[length-qs][(qs-1)+gs-i-1-1]=z;//gs-1-1第一个-1由0开始，第二个是收缩已由右边赋值的一个
                                z++;
                        }
                        //对本圈左边赋值
                        for(int i=0;i<gs-2;i++){
                                arr[(qs-1)+gs-i-1-1][qs-1]=z;
                                z++;
                        }
                }
                return arr;
        }
        /**
         * 打印方法
         */
        public void printer(int[][] sz){
                for(int i=0;i<sz.length;i++){
                        for(int j=0;j<sz[i].length;j++){
                                System.out.print(sz[i][j]+"  ");
                        }
                        System.out.println();
                }
        }
}

主要还是要有一个方向的概念,将二维数组看做一个回型走廊,碰到墙就右转直到走到尽头就行了

[AppleScript] 纯文本查看 复制代码

public class Test {
        public static void main(String[] args) {
                System.out.println("请输入圈数:");
                Scanner sc = new Scanner(System.in);
                int quan = sc.nextInt();
                int[][] arr = new int[quan][quan];
                
                int fangxiang = 1;//1,2,3,4分别代表右,下,左,上
                //计数变量
                int num = 1;
                //行数
                int h = 0;
                //列数
                int l = 0;
                //开始输入
                while(num <= quan * quan) {
                        //将num存入数组并加一
                        arr[h][l] = num;
                        num++;
                        //判断下一步的方向并执行相应操作
                        switch(fangxiang) {
                        case 1:
                                if(l + 1 < quan && arr[h][l + 1] == 0) {//索引不越界,并且在该方向上下一个值未被赋值
                                        l++;//沿方向增长
                                }else {
                                        fangxiang = 2;//改变方向
                                        h++;//沿方向增长
                                }
                                break;
                        case 2:
                                if(h + 1 < quan && arr[h + 1][l] == 0) {
                                        h++;
                                }else {
                                        fangxiang = 3;
                                        l--;
                                }
                                break;
                        case 3:
                                if(l - 1 >= 0 && arr[h][l - 1] == 0) {
                                        l--;
                                }else {
                                        fangxiang = 4;
                                        h--;
                                }
                                break;
                        case 4:
                                if(h - 1 >= 0 && arr[h - 1][l] == 0) {
                                        h--;
                                }else {
                                        fangxiang = 1;
                                        l++;
                                }
                                break;
                                default:
                        }
                }
                //遍历输出数组
                for(int i = 0; i < arr.length; i++) {
                        for(int j = 0; j < arr[i].length; j++) {
                                System.out.print(arr[i][j] + " ");
                        }
                        System.out.println();
                }
        }
}