A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

Java基础流程控制语句中关于打印三角形的案例是一道趣味性和应用性很强的案例,为了方便学习,我把相关的案例总结了下,希望对大家有用.当然这次总结的案例相对简单,很多复杂的比如螺旋矩形,空心菱形之类的图案打印也是借鉴了其中的思想,但是由于比较复杂,暂时先不加入本帖,大家感兴趣的话,我找时间再总结进来.代码都是自己敲过的,应该没错,大家也可以自己练习下看是否对自己的学习有用.相关案例如下:
1.打印正三角形和倒三角形
  1. public class  TriAngle {
  2.         public static void main(String[] args) {
  3.                         fun1();        //正三角形
  4.                         System.out.println("-----------");
  5.                         fun2();        //倒三角形
  6.         }

  7.         private static void fun2() {
  8. //                        外循环控制行数
  9.                 for (int i = 5; i >0 ; i--) {       
  10. //                        内循环控制列数,观察列数变化是随着行数变化而变化,只需要满足j<i即可.
  11.                         for (int j = 0; j < i; j++) {
  12. //                                打印每一行的"*"的个数
  13.                                 System.out.print("* ");                               
  14.                         }
  15. //                                换行
  16.                         System.out.println();
  17.                 }
  18.         }

  19.         private static void fun1() {
  20. //                        外循环控制行数
  21.                 for (int i = 1; i <=5 ; i++) {       
  22. //                        内循环控制列数,观察列数变化是随着行数变化而变化,只需要满足j<i即可.
  23.                         for (int j = 0; j < i; j++) {
  24. //                                打印每一行的"*"的个数
  25.                                 System.out.print("* ");                               
  26.                         }
  27. //                                换行
  28.                         System.out.println();
  29.                 }
  30.         }
  31.        
  32. }
复制代码

2.打印等腰三角形
  1. /*打印等腰三角形
  2. *           i    空             *    首先:外层循环控制行数,内循环第一个控制空格,第二个控制 * 号
  3.     *        0    4    1    分析:i和空格关系得出:空格 = 4 - i; 也就是 :line - i -1; 因为line=5;
  4.    ***       1    3    3    分析:i和 *  关系得出:  *  = 2 * i + 1;
  5.   *****      2    2    5    当i=0时,第一行 打印了一个 * ,并且 * 左边有4个空格,由此得出内循环的
  6. *******     3    1    7    条件判断是:j< 4-i;  即: i =0 , j=0;j<4-i;j++; 循环后就得到4空格,同时
  7. *********    4    0    9                            i =0 , j=0;j<2*i+1;j++; 循环后就得到一个 *
  8.                                                     以此类推:即可得到正的一个等腰三角形

  9.              i   空   *   分析: i和空格关系,明显 i = 空格, i 和 * 的关系有点复杂, 首先需要考虑i
  10. *********    0   0    9         还要考虑行数line的值,经分析得出: *  = 2*line - 2* i -1;
  11. *******     1   1    7   当i = 0, 进入内循环, j = 0;j<i;j++; 刚才分析得出 :空格 =i ,那么这里为  
  12.   *****      2   2    5   什么j<i呢,因为第一行不打印空格
  13.    ***       3   3    3   当i = 0, 进入内循环, j = 0;j<2*line -2*i -1;j++; 即:j=0;j<9;j++; 那么
  14.     *        4   4    1   就循环吧,打印9颗星, 之后i=1,2,3,4就解决了.

  15. *
  16. * */

  17. public class ThreeAngle1 {
  18.         public static void main(String[] args) {
  19.                 fun(5);
  20.                 System.out.println("----------");
  21.                 fun1(5);
  22.                
  23.         }

  24.         private static void fun1(int line) {
  25.                 for(int i=0;i<line;i++){
  26.             for(int j=0;j<i;j++){
  27.                 System.out.print(" ");   
  28.             }
  29.             for(int j=0;j<2*line-2*i -1;j++){
  30.                 System.out.print("*");   
  31.             }
  32.             System.out.println();        
  33.         }
  34.         }

  35.         private static void fun(int line) {
  36.                 for (int i = 0; i <line; i++) {
  37.                         for (int j = 0; j < line-i-1; j++) {
  38.                                 System.out.print(" ");
  39.                         }
  40.                         for (int j = 0; j<2*i+1; j++) {
  41.                                 System.out.print("*");
  42.                                
  43.                         }
  44.                         System.out.println();
  45.                 }
  46.         }

  47. }
复制代码


3.在控制台输出九九乘法表。
public class Test8 {
        public static void main(String[] args) {

                for (int x = 1; x <= 9; x++) {
                        for (int y = 1; y <= x; y++) {
                                System.out.print(y + "*" + x + "=" + y * x + "\t");
                        }
                        System.out.println();
                }
        }
}

4.打印杨辉三角形(行数可以键盘录入)。
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1


分析:看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。

步骤:
A:首先定义一个二维数组。行数如果是n,我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。
  1. import java.util.Scanner;
  2. public class Test9 {
  3.         public static void main(String[] args) {
  4.                 // 创建键盘录入对象
  5.                 Scanner sc = new Scanner(System.in);

  6.                 // 这个n的数据来自于键盘录入。
  7.                 System.out.println("请输入一个数据:");
  8.                 int n = sc.nextInt();

  9.                 // 定义二维数组
  10.                 int[][] arr = new int[n][n];

  11.                 // 给这个二维数组任何一行的第一列和最后一列赋值为1
  12.                 for (int x = 0; x < arr.length; x++) {
  13.                         arr[x][0] = 1; // 任何一行第1列
  14.                         arr[x][x] = 1; // 任何一行的最后1列
  15.                 }

  16.                 // 按照规律给其他元素赋值
  17.                 // 从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
  18.                 for (int x = 2; x < arr.length; x++) {
  19.                         // 这里如果y<=x是有个小问题的,就是最后一列的问题
  20.                         // 所以这里要减去1
  21.                         // 并且y也应该从1开始,因为第一列也是有值了
  22.                         for (int y = 1; y <= x - 1; y++) {
  23.                                 // 每一个数据是它上一行的前一列和它上一行的本列之和。
  24.                                 arr[x][y] = arr[x - 1][y - 1] + arr[x - 1][y];
  25.                         }
  26.                 }

  27.                 // 遍历这个二维数组。
  28.                
  29.                 // 这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似
  30.                 for (int x = 0; x < arr.length; x++) {
  31.                         for (int y = 0; y <= x; y++) {
  32.                                 System.out.print(arr[x][y] + "\t");
  33.                         }
  34.                         System.out.println();
  35.                 }
  36.         }

  37. }
复制代码

点评

已收藏~  发表于 2015-5-27 21:35

6 个回复

倒序浏览
我能说代码的层次很乱吗,哪里到哪里算是循环的开始和结束要查看半天 { } ,这种书写格式感觉很不好哦~
回复 使用道具 举报
哪个案例的代码乱了?
回复 使用道具 举报
hellotaomi 发表于 2015-5-27 14:09
我能说代码的层次很乱吗,哪里到哪里算是循环的开始和结束要查看半天 { } ,这种书写格式感觉很不好哦~ ...

哪个案例代码乱了?就用的for循环的嵌套而已啊.
回复 使用道具 举报
hellotaomi 发表于 2015-5-27 14:09
我能说代码的层次很乱吗,哪里到哪里算是循环的开始和结束要查看半天 { } ,这种书写格式感觉很不好哦~ ...

我是在eclipse上做的,老师教我们就是这种格式,后期学习的时候方便.当然了,为了方便我的三角形的案例是把正三角和倒三角放到一个案例上了
回复 使用道具 举报
等腰三角形我弄好好久才弄出来。向楼主学习
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马