正整数n型方阵

正整数n型方阵（不用数组完成）

一般呢这种n型方阵很多人都是用数组完成，今天呢小编就用简单的循环控制结构来完成，不需用到数组。
题目：
从键盘输入一个正整数n，根据n形成一个方阵。方阵最外层是第一层，每层上用的数字与层数相同。
如输入3，则方阵为：
1 1 1 1 1
1 2 2 2 1
1 2 3 2 1
1 2 2 2 1
1 1 1 1 1

题目规律：

（1）n型方阵有2n-1行，2n-1列
（2）在两层循环里i代表行，j代表列；n型方阵以第n行第n列为对称轴，上下左右四个角对称，这是很重要的规律。
（3）代码块分析
（对应代码块看比较清晰）
分为五大模块：
第一模块：第n行时的情况，第n行呢以第n列为中心，左右列上的数字对称，第n行第1到n列的输出，此时第几列上的数字为列数，j此时代表列，在j小于等于n的情况下j++输出了第n行第1~n列的情况；第n行第（n+1）到（2n-1）列的输出，j此时在这里代表列数，但又因为第（n+1） 到（2n-1）列上的数字跟第1到n列对称，所以要通过j的变换来得到第（n+1）到（2n-1）列上的数字，可是又不能影响j在这里代表的内循环，故下面的变量的t就有作用啦。
第二模块：第1到n行的情况，也是以第n列为中心，左右列上的数字对称，也就是说在同一行所对称的列数上的数字相等。
第1到n列的情况j代表列，i代表行，当列数大于行数时，输出i（行数号），也就是说此时i为这一列上对应方阵的数字， 当列数小于行数时，输出j（列数号），也就是说此时j为这一列上对应方阵的数字 。
第三模块：第1到n行第n到（2n-1）列的情况，为了方便确定第n到（2n-1）列上对应的方阵数字，在这里第n到（2n-1）列看成第(n-1)~1列，即从右边来看列数即这个时候在这个情况里从右边开始算起从第一列开始，所以此时j既代表列数又代表这一列所对应的方阵的数字。j代表列，i代表行，当列数大于行数时，输出i（行数号），也就是说此时i为这一列上对应方阵的数字 ；当列数小于行数时，输出j（列数号），也就是说此时j为这一列上对应方阵的数字。
第四模块： 第（n+1）到(2n-1)行第1到n列的情况。
第五个：第（n+1）到(2n-1)行第n~（2n-1）列的情况。

代码块：（对应代码解析）

import java.util.Scanner;
public class fanzheng {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    Scanner input= new Scanner(System.in);
    System.out.println("请输入一个正整数：");
    int n=input.nextInt();//n型方阵有2n-1行，2n-1列
    for(int i=1;i<2*n;i++){
        //在两层循环里i代表行，j代表列；n型方阵以第n行第n列为对称轴，上下左右四个角对称。这是很重要的规律
        if(i==n){//第n行时的情况，第n行呢以第n列为中心，左右列上的数字对称
            for(int j=1;j<n+1;j++){
                System.out.print(j+"\t");//第n行第1~n列的输出，此时第几列上的数字为列数，j此时代表列，在j小于等于n的情况下j++输出了第n行第1~n列的情况
            }
            for(int j=n+1;j<2*n;j++){
                /*第n行第（n+1）~（2n-1）列的输出，j此时在这里代表列数，但又因为第（n+1）
                 * ~（2n-1）列上的数字跟第1~n列对称，所以要通过j的变换来得到第（n+1）~
                 * （2n-1）列上的数字，可是又不能影响j在这里代表的内循环，故下面的变量的t就有作用啦*/
                int t=j;//将j的值先赋值给t,通过变量t来保存内循环for这里第几列的列数
                int c=j-n;//j减去n代表此时第j列距离第n列的距离
                j=n-c;
                /*n减去c此时得到以第n列为对称轴右边第（n+1）~（2n-1）列对应到左边的那一列
                 * ，又因为对称的两列上的数字会相等并且第n行第1~n列上的数字刚好为第几列列数，
                 * 所以此时这里的j代表的是第n行右边也就是列数范围为（n+1）~（2n-1）的第t
                 * 列（也就是原来的第j列）上的数字*/
                System.out.print(j+"\t");/*此时这里的j代表的是第n行右边也就是列数
                范围为（n+1）~（2n-1）的第t列（也就是原来的第j列）上的数字,赶紧输出来*/
                j=t;//将代表列数的t赋回给j;不影响内层循环for
            }    
            System.out.println();//换行，因为此时第n行都全部输出了，就要及时换行
        }
        if(i<n){//第1~n行的情况，也是以第n列为中心，左右列上的数字对称，也就是说在同一行所对称的列数上的数字相等，
            for(int j=1;j<n+1;j++){//第1~n列的情况
                if(j>=i){
                    System.out.print(i+"\t");//j代表列，i代表行，当列数大于行数时，输出i（行数号），也就是说此时i为这一列上对应方阵的数字    
                }
                else {
                    System.out.print(j+"\t");//j代表列，i代表行，当列数小于行数时，输出j（列数号），也就是说此时j为这一列上对应方阵的数字    
                }    
            }
            
            for(int j=n+1;j<2*n;j++){//第n~（2n-1）列的情况，下面的t,j,c的用法跟第n行第n~（2n-1）列的用法意思差不多一样
                int t=j;
                int c=j-n;
                j=n-c;/*为了方便确定第n~（2n-1）列上对应的方阵数字，在这里第n~（2n-1）
                                     列看成第(n-1)~1列，即从右边来看列数即这个时候在这个情况里从右边开始算起从第一列开始，所以此时j既代表列数又代表这一列所对应
                                     的方阵的数字*/
                if(j>=i){
                    System.out.print(i+"\t");//j代表列，i代表行，当列数大于行数时，输出i（行数号），也就是说此时i为这一列上对应方阵的数字    
                }
                else{
                    System.out.print(j+"\t");//j代表列，i代表行，当列数小于行数时，输出j（列数号），也就是说此时j为这一列上对应方阵的数字    
                }
                j=t;  
            }
            System.out.println();
          }
        if(i>n){//第（n+1）~(2n-1)行的情况
           for(int j=1;j<n+1;j++){//第1~n列的情况，下面的解释跟上面的一样结合第一第二个if的解释，因为以第n行第n列为对称轴上下左右对称
               int f=i;
               int c=f-n;
               f=n-c;
               if(j<=f){
                   System.out.print(j+"\t");
               }
               else{
                   System.out.print(f+"\t");
               }
               
           }
           for(int j=n+1;j<2*n;j++){//第n~（2n-1）列的情况，下面的解释跟上面的一样结合第一第二个if的解释，因为以第n行第n列为对称轴上下左右对称
               int f=i;
               int c=f-n;
               f=n-c;
               int t=j;
               int g=j-n;
               j=n-g;
               if(j<=f){
                   System.out.print(j+"\t");
               }
               else{
                   System.out.print(f+"\t");
               }
              j=t; 
           }
           System.out.println();
       }
        input.close();
     }
   }
}

输入正整数3运行结果：