构造一个矩阵，例如，
当输入阶数为1时，输出1        当输入阶数为2时，输出 1  1     ...    当输入为5时，输出1  1  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  1  1  1  1
1  2  2  2  1
1  2  3  2  1
1  2  2  2  1
1  1  1  1  1

是不是最终要达到这样的效果?

马镱洵 发表于 2012-9-23 15:51
1  1  1  1  1
1  2  2  2  1
1  2  3  2  1

根据输入的阶数来确定啊，如果输入的是6，里面还可以包含一层

1. public class RectangleTest {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 printRectangle(6, 6);
   
5.         }
   
6. 
   
7.         /**
   
8.          * 输出一个矩形
   
9.          *
   
10.          * @param row
    
11.          *            行数
    
12.          * @param col
    
13.          *            列数
    
14.          */
    
15.         public static void printRectangle(int row, int col) {
    
16.                 int midRow = 0;// 中间行
    
17.                 int midCol = 0;// 中间列
    
18.                 int temp = row % 2;// 计算出行数为奇数还是偶数
    
19.                 int temp2 = col % 2;// 计算出列数为奇数还是偶数
    
20.                 for (int i = 1; i <= row; i++) {
    
21.                         for (int j = 1; j <= col; j++) {
    
22.                                 if (i == 1 || i == row) {// 当前行为1或当前行为最后一行时
    
23.                                         System.out.print(1 + " ");
    
24.                                 } else if (j == 1 || j == col) {// 当前列为1或当前列为最后一列时
    
25.                                         System.out.print(1 + " ");
    
26.                                 } else if (j != 1 && j != col) {// 当前列不为1且当前列不为列数时
    
27.                                         if (temp == 1) {// 如果行数为奇数
    
28.                                                 midRow = row / 2 + 1;// 计算出中间行是哪一行
    
29.                                                 if (i == midRow) {// 如果当前行等于中间行
    
30.                                                         if (temp2 == 1) {// 如果列数为奇数时
    
31.                                                                 midCol = col / 2 + 1;// 计算出中间列是哪一列
    
32.                                                                 if (j == midCol) {// 如果当前列等于中间列时
    
33.                                                                         System.out.print(j + " ");
    
34.                                                                         continue;
    
35.                                                                 }
    
36.                                                         } else {// 如果列数为偶数时
    
37.                                                                 midCol = col / 2;// 计算出中间列是哪一列
    
38. 
    
39.                                                                 // 如果当前列等于中间列或当前列等于中间列的后一列,
    
40.                                                                 // 为什么要这样做呢,因为当列数为偶数时,
    
41.                                                                 // 中间列应该有两列吧.
    
42.                                                                 if (j == midCol || j == midCol + 1) {
    
43.                                                                         System.out.print(i + " ");
    
44.                                                                 }
    
45.                                                         }
    
46.                                                 }
    
47.                                                 System.out.print(2 + " ");
    
48.                                         } else if (temp == 0) {// 如果行数为偶数时
    
49.                                                 midRow = row / 2;// 计算出中间行是哪一行
    
50. 
    
51.                                                 // 如果当前行等于中间行或当前行等于中间行的下一行,
    
52.                                                 // 为什么要这样做呢,因为当行数为偶数时,
    
53.                                                 // 中间行应该有两行吧.
    
54.                                                 if (i == midRow || i == midRow + 1) {
    
55.                                                         if (temp2 == 1) {// 当列数为奇数时
    
56.                                                                 midCol = col / 2 + 1;// 计算出中间列是哪一列
    
57.                                                                 if (j == midCol) {// 如果当前列等于中间列时
    
58.                                                                         System.out.print(j + " ");
    
59.                                                                 }
    
60.                                                         } else {// 当列数为偶数时
    
61.                                                                 midCol = col / 2;// 计算出中间列是哪一列
    
62. 
    
63.                                                                 // 如果当前列等于中间列或当前列等于中间列的下一列时
    
64.                                                                 if (j == midCol || j == midCol + 1) {
    
65.                                                                         System.out.print(j + " ");
    
66.                                                                         continue;
    
67.                                                                 }
    
68.                                                         }
    
69.                                                 }
    
70.                                                 System.out.print(2 + " ");
    
71.                                         }
    
72.                                 }
    
73.                         }
    
74.                         // 最后当然少不了要换行
    
75.                         System.out.println();
    
76.                 }
    
77.         }
    
78. 
    
79. }

复制代码