乐趣区

关于java:Java输出形状

jiezi

输入矩形

以此矩形案例（4 行，9 列的矩形）为例 

public static void main(String[] args) {
        // 输入矩形
        for (int i = 1; i <= 4; i++) {// 管制行，即 4 行
            for (int j = 1; j <= 9; j++) {// 管制输入的 * 的个数，每行 9 个
                System.out.print("*");
            }
            // 换行
            System.out.println();}
    }

// 输入后果
*********
*********
*********
*********

后面有空格的矩形

以此矩形案例（4 行，9 列的矩形）为例 

public static void main(String[] args) {
        // 输入后面有空格矩形
        for (int i = 1; i <= 4; i++) {// 管制行，即 4 行
            // 输入空格
            for (int k = 1; k <= 5; k++) {// 管制空格，即每行开始输入 5 个空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 9; j++) {// 管制输入的 * 的个数，每行 9 个
                System.out.print("*");
            }
            // 换行
            System.out.println();}
    }

// 输入后果
     *********
     *********
     *********
     *********

输入平行四边形

以此矩形案例（4 行，9 列的矩形）为例，要变成平行四边形

  • 第一行后面输入 8 个空格
  • 第二行后面输入 7 个空格
  • 第三行后面输入 6 个空格
  • 第四行后面输入 5 个空格 
        ********* 1 8
       ********* 2 7
      ********* 3 6
     ********* 4 5

综上所述，得出法则：行数 + 空格数 =9

public static void main(String[] args) {
        // 输入平行四边形
        for (int i = 1; i <= 4; i++) {// 管制行，即 4 行
            // 输入空格
            for (int k = 1; k <= 9 - i; k++) {// 管制空格，行数 + 空格数 =9，即每行开始输入 9 - i 个空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 5; j++) {// 管制输入的 * 的个数，每行 5 个
                System.out.print("*");
            }
            // 换行
            System.out.println();}
    }

// 输入后果：*****
       *****
      *****
     *****

输入三角形

以此案例（4 行）为例，要变成三角形

  • 第一行后面输入 8 个空格，1 个星
  • 第二行后面输入 7 个空格，3 个星
  • 第三行后面输入 6 个空格，5 个星
  • 第四行后面输入 5 个空格，7 个星 
        * 1 8 1
       *** 2 7 3
      ***** 3 6 5
     ******* 4 5 7

综上所述，得出法则：行数 + 空格数 =9，2x 行数 -1= 星的个数 

public static void main(String[] args) {
        // 输入三角形
        for (int i = 1; i <= 4; i++) {// 管制行，即 4 行
            // 输入空格
            for (int k = 1; k <= 9 - i; k++) {// 管制空格，行数 + 空格数 =9，即每行开始输入 9 - i 个空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {// 管制输入的 * 的个数，2x 行数 -1= 星的个数，即每行 2 * i - 1 个星
                System.out.print("*");
            }
            // 换行
            System.out.println();}
    }

// 输入后果：*
       ***
      *****
     *******

输入菱形

此案例由下面三角形（4 行）和上面倒三角形（3 行）组合，变成菱形

下面三角形

  • 第一行后面输入 8 个空格，1 个星
  • 第二行后面输入 7 个空格，3 个星
  • 第三行后面输入 6 个空格，5 个星
  • 第四行后面输入 5 个空格，7 个星

上面倒三角形

  • 第一行后面输入 6 个空格，5 个星
  • 第二行后面输入 7 个空格，3 个星

  • 第三行后面输入 8 个空格，1 个星 

          * 1 8 1
     *** 2 7 3
    ***** 3 6 5
   ******* 4 5 7
    *****   1 6 5
     ***     2 7 3
      *       3 8 1

综上所述，得出法则：下面三角形，行数 + 空格数 =9，2x 行数 -1= 星的个数；上面倒三角形，行数 +5= 空格数，7-2x 行数 = 星的个数 

public static void main(String[] args) {
        // 输入下面三角形
        for (int i = 1; i <= 4; i++) {// 管制行，即 4 行
            // 输入空格
            for (int k = 1; k <= 9 - i; k++) {// 管制空格，行数 + 空格数 =9，即每行开始输入 9 - i 个空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {// 管制输入的 * 的个数，2x 行数 -1= 星的个数，即每行 2 * i - 1 个星
                System.out.print("*");
            }
            // 换行
            System.out.println();}

        // 输入上面倒三角形
        for (int i = 1; i <= 3; i++) {// 管制行，即 3 行
            // 输入空格
            for (int k = 1; k <= i + 5; k++) {// 管制空格，行数 +5= 空格数，即每行开始输入 i + 5 个空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 7 - 2 * i; j++) {// 管制输入的 * 的个数，7-2x 行数 = 星的个数，即每行 7 - 2 * i 个星
                System.out.print("*");
            }
            // 换行
            System.out.println();}
    }

// 输入后果：*
       ***
      *****
     *******
      *****
       ***
        *

输入空心菱形

此案例由下面三角形（4 行）和上面倒三角形（3 行）组合，变成菱形，两头星形由空格代替 

        * 
       * * 
      *   * 
     *     * 
      *   *   
       * *     
        *

得出法则：在输入星的中央，每行第一个和最初一个输入星，其余输入空格 

 public static void main(String[] args) {
        // 输入下面三角形
        for (int i = 1; i <= 4; i++) {// 管制行，即 4 行
            // 输入空格
            for (int k = 1; k <= 9 - i; k++) {// 管制空格，行数 + 空格数 =9，即每行开始输入 9 - i 个空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {// 管制输入的 * 的个数，2x 行数 -1= 星的个数，即每行 2 * i - 1 个星
                // 在首和尾输入星，其余输入空格
                if (j == 1 || j == 2 * i - 1) {System.out.print("*");
                } else {System.out.print(" ");
                }
            }
            // 换行
            System.out.println();}

        // 输入上面倒三角形
        for (int i = 1; i <= 3; i++) {// 管制行，即 3 行
            // 输入空格
            for (int k = 1; k <= i + 5; k++) {// 管制空格，行数 +5= 空格数，即每行开始输入 i + 5 个空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 7 - 2 * i; j++) {// 管制输入的 * 的个数，7-2x 行数 = 星的个数，即每行 7 - 2 * i 个星
                // 在首和尾输入星，其余输入空格
                if (j == 1 || j == 7 - 2 * i) {System.out.print("*");
                } else {System.out.print(" ");
                }
            }
            // 换行
            System.out.println();}
    }

// 输入后果：*
       * *
      *   *
     *     *
      *   *
       * *
        *

输入正方形

以此案例（5 行，5 列的正方形）为例 

public static void main(String[] args) {
        // 输入正方形
        int len = 5;// 正方形边长
        for (int i = 1; i <= len; i++) {// 管制行，即 4 行
            for (int j = 1; j <= len; j++) {// 输入星，即每行输入 j 个星
                System.out.print("*");
            }
            // 换行
            System.out.println();}
    }

// 输入后果：*****
*****
*****
*****
*****

输入实心菱形

以此案例（5 行，5 列）为例

  • 第一行第一个和最初一个星的地位是 3 和 3
  • 第二行第一个和最初一个星的地位是 2 和 4
  • 第三行第一个和最初一个星的地位是 1 和 5
  • 第四行第一个和最初一个星的地位是 2 和 4
  • 第五行第一个和最初一个星的地位是 3 和 3 
  *  1 3 3
 ***  2 2 4
*****  3 1 5
 ***    4 2 4 
  *      5 3 3 
public static void main(String[] args) {
        // 输入实心菱形
        int len = 5;// 边长
        int first = len / 2 + 1;// 开始输入星的地位
        int end = len / 2 + 1;// 完结输入星的地位
        boolean flag = true;// 如果是上半部三角形则是 true，如果是下半倒三角形则是 false

        for (int i = 1; i <= len; i++) {// 管制行，即 4 行
            for (int j = 1; j <= len; j++) {// 输入星，即每行输入 j 个星
                if (j >= first && j <= end) {// 在每行的起始至完结地位输入星
                    System.out.print("*");
                } else {System.out.print(" ");
                }
            }
            // 换行
            System.out.println();

            if(end == len){// 最初一个星地位是边长宽度
                flag = false;// 下一行，马上执行下半部倒三角形
            }

            if(flag){
                // 在上半三角形，开始输入星的地位 first 前移 1，完结输入星的地位 end 后移 1
                first--;
                end++;
            }else {
                // 在下半倒三角形，开始输入星的地位 first 后移 1，完结输入星的地位 end 前移 1
                first++;
                end--;
            }
        }
    }

// 输入后果：*  
 *** 
*****
 *** 
  *

如果想输入空心菱形则只须要将：

if (j >= first && j <= end)

改成 

if (j == first || j == end)
退出移动版