1. public class Triangle {
   
2.     public static void main(String[] args) {
   
3.         // TODO Auto-generated method stub
   
4.         int row = 8;
   
5.         int colunm = 8;
   
6.         int f = 1;
   
7.         int row2 = row / 2;
   
8.         int colunm2 = colunm / 2;
   
9.         // 1****************左上三角
   
10.         System.out.println("--1左上三角--" + f++ + "---");
    
11.         for (int i = 0; i < row; i++) {
    
12.             for (int j = 0; j < colunm - i; j++) {
    
13.                 System.out.print("*");
    
14.             }
    
15.             System.out.println("");
    
16.         }
    
17. 
    
18.         System.out.println("");
    
19.         System.out.println("");
    
20. 
    
21.         // 2****************左下三角
    
22.         System.out.println("-2左下三角---" + f++ + "---");
    
23.         for (int i = 0; i < row; i++) {
    
24.             for (int j = 0; j < i; j++) {
    
25.                 System.out.print("*");
    
26.             }
    
27.             System.out.println("");
    
28.         }
    
29. 
    
30.         System.out.println("");
    
31.         System.out.println("");
    
32. 
    
33.         // 3****************左下右上组合，把-符号改了就是右上了
    
34.         System.out.println("-3左下右上组合---" + f++ + "---");
    
35.         for (int i = 0; i < row; i++) {
    
36.             // 换行的时候，每次做内层的时候j必须要清0
    
37.             int head = 0;
    
38.             // 外层循环只要循环他要循环的就可以了，用边界条件限制
    
39.             // 因为是先做内层循环的事情的
    
40.             for (int j = 0; j < colunm - i; j++) {
    
41.                 while (head < i) {
    
42.                     System.out.print("-");
    
43.                     head++;
    
44.                 }
    
45.                 System.out.print("*");
    
46.             }
    
47.             System.out.println("");
    
48.         }
    
49. 
    
50.         System.out.println("");
    
51.         System.out.println("");
    
52. 
    
53.         // 4****************右下左上组合，把-符号改了就是右下了
    
54.         System.out.println("-4右下左上组合---" + f++ + "---");
    
55.         for (int i = 0, j = 0; i < row; i++) {
    
56.             // 换行的时候，每次做内层的时候j必须要清0
    
57.             j = 0;
    
58.             for (int k = 0; k < colunm - j + 1; k++) {
    
59.                 while (j < colunm - i) {
    
60.                     System.out.print("-");
    
61.                     j++;
    
62.                 }
    
63.                 System.out.print("*");
    
64.             }
    
65.             System.out.println("");
    
66.         }
    
67.         System.out.println("");
    
68.         System.out.println("");
    
69.     }
    
70. 
    
71. }
    
72. 
    

复制代码

1. public class Test8 {
   
2.     public static void main(String[] args) {
   
3.         // 自定义行列,行数必须大于等于列数，形状才符合
   
4.         int row = 24;
   
5.         int colunm = 24;
   
6.         int row2 = row / 2;
   
7.         int colunm2 = colunm / 2;
   
8. 
   
9.         System.out.println("********************************************");
   
10.         System.out.println("");
    
11.         //***********上半部分左边右边大结合
    
12.         for (int i = 0, jL = 0, k = 0, jR = 0, j = 0; i < row; i++) {
    
13. 
    
14.             // 左边，上
    
15.             // j_l左边起始的指针
    
16.             // j总指针，从0到尽头16-1
    
17.             // k遍历列
    
18.             while (j < colunm2 - 1) {
    
19.                 for (k = 0; k < colunm2 - jL + 1; k++) {
    
20.                     while (jL < colunm2 - i) {
    
21.                         System.out.print("1");
    
22.                         jL++;
    
23.                         j++;
    
24.                     }
    
25.                     // jL已经完成使命，不再使用
    
26.                     j++;
    
27.                     System.out.print("2");
    
28.                 }
    
29. 
    
30.             }
    
31. 
    
32.             // 右边,下
    
33.             // jR右边起始为0的指针
    
34.             while (j >= colunm2 - 1 && j < colunm - 1) {
    
35.                 for (k = 0; k < colunm - j + 2;) {
    
36.                     while (jR < i + 1) {
    
37.                         System.out.print("3");
    
38.                         jR++;
    
39.                         j++;
    
40.                     }
    
41.                     j++;
    
42.                     System.out.print("4");
    
43.                 }
    
44.             }
    
45. 
    
46.             // 每换一行，指针清零
    
47.             jL = 0;
    
48.             jR = 0;
    
49.             j = 0;
    
50.             System.out.println("");
    
51.             
    
52.             // i到达中间的时候
    
53.             if (i > row2 - 2 && i < row - 1) {
    
54.                 int row_D = row - row2;
    
55.                 down(row_D, colunm2, colunm);
    
56.                 break;
    
57.             }
    
58.         }
    
59. 
    
60.     }
    
61.     //下半部分左边右边大结合
    
62.     private static void down(int row, int colunm2, int colunm) {
    
63. 
    
64.         int b = 0;
    
65.         for (int i = 0, jL = 0, k = 0, jR = 0, j = 0; i < row; i++) {
    
66.         
    
67.             // 当处于右下左边时
    
68.             while (j < colunm2 - 1) {
    
69.                 for (k = 0; k < colunm2 - i; k++) {
    
70.                     while (jL < i + 1) {
    
71.                         System.out.print("5");
    
72.                         jL++;
    
73.                         j++;
    
74.                     }
    
75.                     j++;
    
76.                     System.out.print("6");
    
77. 
    
78.                 }
    
79.             }
    
80.             
    
81.             // 当处于右下右边时
    
82.             while (j > colunm2 && j < colunm) {
    
83.                 for (k = 0; k < colunm - jR - row + 1; k++) {
    
84.                     while (jR < colunm2 - i) {
    
85.                         System.out.print("7");
    
86.                         j++;
    
87.                         jR++;
    
88.                     }
    
89.                     j++;
    
90.                     
    
91.                     System.out.print("8");
    
92.                 }               
    
93.             }
    
94.         
    
95.             // 每换一行，指针清零
    
96.             jL = 0;
    
97.             jR = 0;
    
98.             j = 0;
    
99. 
    
100.             // 换行
     
101.             System.out.println("");            
     
102.         }
     
103.     }
     
104. 
     
105. }
     
106. 
     

复制代码

1. public class Test2 {
   
2.     public static void main(String[] args)  {
   
3.         //自定义行列
   
4.         int row = 7;
   
5.         int colunm = 13;
   
6.         int [][] a = new int [row][colunm];
   
7.         for(int i = 0, j = 0; i < row;i++){
   
8.             //如果大于最后一行-2，即到达最后一行-1，则按第2规律执行，否则按第1规律执行
   
9.             if(i > row-3){
   
10.                 for(j = i; j < colunm - i;j++){
    
11.                     a[i][j] = 1;
    
12.                 }
    
13.                 continue;
    
14.             }
    
15.             
    
16.             int head = 0;
    
17. 
    
18.             //元素行与列位置相同，遍历列，遍历长度小于最右边元素长度
    
19.             for(j = i; j < colunm - i;j++){
    
20.                
    
21.                 //当元素下标等于3,到达空白处；下标等于最右边元素位置-3，可以到达空白处
    
22.                 if(head == 2 || head == (colunm - 1) -2*i -2){
    
23.                     a[i][j] = 0;
    
24.                 }else{
    
25.                     a[i][j] = 1;
    
26.                 }
    
27.                 //前面下标++，换行时，重置为0
    
28.                 head++;               
    
29.             }        
    
30.         }
    
31. 
    
32.         //倒置输出上半部
    
33.         for(int i = row - 1; i > 0; i--){
    
34.             for(int j = 0; j < colunm; j++){
    
35.                 if(a[i][j] == 1){
    
36.                     System.out.print("*");
    
37.                 }else if(a[i][j] == 0 ){
    
38.                     System.out.print(" ");
    
39.                 }
    
40.             }
    
41.             System.out.println();            
    
42.         }
    
43.         //输出下半部
    
44.         for(int i = 0; i < row; i++){
    
45.             for(int j = 0; j < colunm; j++){
    
46.                 if(a[i][j] == 1){
    
47.                     System.out.print("*");
    
48.                 }else if(a[i][j] == 0 ){
    
49.                     System.out.print(" ");
    
50.                 }
    
51.             }
    
52.             System.out.println();            
    
53.         }
    
54.     }
    
55. }
    
56. 
    
57. //修改了一下代码，把图中end下标去除了，将head判断处改为head == (colunm - 1) -2*i -2

复制代码

真心花了不少时间，不过还是在摸索中懂了很多东西
for的联系到此为止了
其实上面的方法并不是很好，效率可能还行，但是我觉得二维数组做起来会更简单
当年在学校学C语言的时候，作业还是copy别人的，现在自己弄了一下其实也没太难，只是有些麻烦
有感兴趣的，可以拿去参考，欢迎拍砖

很好啊，找到for循环的思想，循环套循环，大圈套小圈的思想，很好搞定

{:soso_e179:}