【原】Java学习笔记006 - 流程控制

 package cn.temptation;

 public class Sample01 {
     public static void main(String[] args) {
         // 需求：写一万次"我错了！"

         // 方式1、使用CV大法
         System.out.println("我错了！");
         System.out.println("我错了！");
         System.out.println("我错了！");
         System.out.println("我错了！");
         // ...

         // 方式2、机械的重复的动作，很傻，考虑让计算机去做，引入了循环的概念
         // 循环怎么理解？
         // 循：按照一定的规律
         // 环：闭合的圆，重复的

         // 循环的形式：
         /*
          * 1、while循环
          * 2、do...while循环
          * 3、for循环
          */
     }
 }

 package cn.temptation;

 public class Sample02 {
     public static void main(String[] args) {
         // while循环（当型循环）

         /*
          * while(条件) { ... }
          * 当条件满足时，一直做某事，直到条件不满足为止
          *
          * while结构中的 { ... } 包含的内容称为循环体
          */

         // 需求：打印显示"我错了！"这句话3遍
         // 定义次数变量
         int count = 0;

         while (count < 3) {
             // 做打印显示的事情
             System.out.println("我错了！");

             // 对次数进行统计（即做了一次打印显示，就让次数加1）
 //            count = count + 1;
 //            count += 1;
 //            count++;
             ++count;

             System.out.println("当前为第" + count + "次");
         }
     }
 }

 package cn.temptation;

 public class Sample03 {
     public static void main(String[] args) {
         // 需求：使用while循环输出10以内的奇数：1、3、5、7、9
         int i = 1;

         // 写法1、考虑连续的奇数之间的间隔为2
 //        while (i < 10) {
 //            System.out.println(i);
 ////            i = i + 2;
 ////            i += 2;
 //
 //            // Invalid argument to operation ++/--
 ////            i++++;
 ////            (i++)++;
 //
 //            // 非要使用自增
 //            i++;
 //            i++;
 //        }

         // 写法2、考虑在while循环中使用自增，但是只对那些和2求余数为1的数字才显示出来
         while (i < 10) {
             // 结合选择结构
             // 判断是否为和2求余数为1的数字
             if (i % 2 == 1) {
                 System.out.println(i);
             }

             i++;
         }
     }
 }

 package cn.temptation;

 public class Sample04 {
     public static void main(String[] args) {
         // 需求：计算从1+2+3+...+100的和
         int i = 1;
         int result = 0;

         // 分步来看1+2+3+...+100这个加法算式
 //        result += 1;
 //        result += 2;
 //        // ...
 //        result += 100;

         // 因为有一定的规律，且重复的在操作，所以考虑使用循环
         while (i <= 100) {
             System.out.println(i);

             result += i;

             // i每次加法操作后都要做一下自增
             i++;
         }

         System.out.println("1+2+3+...+100的总和为：" + result);
     }
 }

 package cn.temptation;

 public class Sample05 {
     public static void main(String[] args) {
         // 需求：世界最高峰珠穆朗玛峰有8848米，现在有一张很大很大的纸，纸的厚度为0.001米，折叠多少次后可以超过珠峰的高度？

         // 思路：纸每次折叠，厚度都会是上一次厚度的2倍

         // 纸的初始厚度
         int height = 1;
         // 折叠次数
         int count = 0;

         while (height <= 8848000) {
             // 纸每次折叠，厚度都会是上一次厚度的2倍
             height = height * 2;

             // 折叠一次，折叠次数加1
             count++;
         }

         System.out.println("折叠了" + count + "次后，就会超过珠峰的高度");
     }
 }

 package cn.temptation;

 public class Sample06 {
     public static void main(String[] args) {
         // 需求：存折中现在有1000块钱，银行的年利息为3.5%，问在银行里放多少年后，连本带利能翻倍？

         // 定义存折的金额
         double cash = 1000.00;
         // 定义目标金额
         double total = cash * 2;
         // 定义年数
         int year = 0;

         while (cash < total) {
             // 本金和利息记为后一年的本金
             cash = (1 + 0.035) * cash;

             year++;
         }

         System.out.println("在银行里放" + year + "年后，连本带利能翻倍");
     }
 }

 package cn.temptation;

 public class Sample07 {
     public static void main(String[] args) {
         // while循环的要点：条件放上头，控制里面走
         int i = 1;

         while (i < 5) {
             i++;        // 显示：2、3、4、5
             System.out.println(i);
 //            i++;        // 显示：1、2、3、4
         }

         // 循环编写时，特别要注意循（按照一定的规律）的规律的归纳总结，这是写好循环的关键
     }
 }

 package cn.temptation;

 public class Sample08 {
     public static void main(String[] args) {
         // 需求：统计100 ~ 999之间的水仙花数并计算有多少个？

         // 规则：以三位数字为例，数字的值 = (百位上的数字 * 百位上的数字 * 百位上的数字)
         //                                    + (十位上的数字 * 十位上的数字 * 十位上的数字)
         //                                    + (个位上的数字 * 个位上的数字 * 个位上的数字)，则称为是一个水仙花数
         // 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3

         // 定义数字变量并赋值
         int number = 100;
         // 定义统计个数用的变量
         int count = 0;

         while (number <= 999) {
             // 关键点：如何获取百位上的数字、十位上的数字、个位上的数字？
             // 个位上的数字
             int i = number / 1 % 10;
             // 十位上的数字
             int j = number / 10 % 10;
             // 百位上的数字
             int k = number / 100 % 10;

             // 根据上面的分析，得到通用的公式，注意求余的10表示的是十进制的含义

             // 规则：以三位数字为例，数字的值 = (百位上的数字 * 百位上的数字 * 百位上的数字)
             //                                    + (十位上的数字 * 十位上的数字 * 十位上的数字)
             //                                    + (个位上的数字 * 个位上的数字 * 个位上的数字)，则称为是一个水仙花数
             // 结合选择结构进行判定
             if (number == i * i * i + j * j * j + k * k *k) {
                 System.out.println(number);
                 // 统计用的变量需要自增
                 count++;
             }

             // 统计的范围从100~999，所以数字需要自增
             number++;
         }

         System.out.println("【100~999】之间的水仙花数有：" + count + "个");
     }
 }

 package cn.temptation;

 public class Sample09 {
     public static void main(String[] args) {
         // 需求：大蜀山上有一段台阶，级数不知道，但是知道如果两个台阶一起跨，还剩1个台阶；
         //        如果三个台阶一起跨，还剩2个台阶；如果四个台阶一起跨，还剩3个台阶；
         //        如果五个台阶一起跨，还剩4个台阶；如果六个台阶一起跨，还剩5个台阶；
         //        如果七个台阶一起跨，一个台阶都不剩。
         //        问：这段台阶最少有多少级？

         // 定义台阶变量
         int step = 1;

         // 思路：运用穷举思想，一个数字一个数字的来尝试是否满足规则

         // 写法1、当台阶数不满足规则的，需要做自增；当找到第1个满足规则的台阶数时，就是最少的满足规则的台阶级数，不用自增了
 //        while (!((step % 2 == 1) && (step % 3 == 2) && (step % 4 == 3) && (step % 5 == 4) && (step % 6 == 5) && (step % 7 == 0))) {
 //            step++;
 //        }
 //
 //        System.out.println("这段台阶最少有" + step + "级");

         // 写法2、构造一个死循环，不断的做自增，在循环体中判断是否满足规则，当找到第1个满足规则的数字时，终止循环跳出
         // while死循环的结构
 //        while (true) {
 //            System.out.println("死循环了么？");
 //        }

         boolean flag = true;
         while (flag) {
             // 对台阶级数进行规则判断
             if ((step % 2 == 1) && (step % 3 == 2) && (step % 4 == 3) && (step % 5 == 4) && (step % 6 == 5) && (step % 7 == 0)) {
                 System.out.println("这段台阶最少有" + step + "级");
                 flag = false;
             }

             step++;
         }
     }
 }

 package cn.temptation;

 public class Sample10 {
     public static void main(String[] args) {
         // 需求：百钱百鸡问题：母鸡一只5元，公鸡一只3元，小鸡三只1元，有100元，如何买到100只鸡？母鸡多少只？公鸡多少只？小鸡多少只？（母鸡、公鸡、小鸡都有）

         // 思路：
         // 从需求中得到一些等式
         // 母鸡数量 + 公鸡数量 + 小鸡数量 = 100
         // 母鸡单价 * 母鸡数量 + 公鸡单价 * 公鸡数量 + 小鸡单价 * 小鸡数量 = 100
         // 小鸡数量是3的倍数

         // 运用"穷举法"
         // 如果买1只母鸡，再买1只公鸡，还能买多少只小鸡
         // 如果买1只母鸡，再买2只公鸡，还能买多少只小鸡
         // ...
         // 如果买2只母鸡，再买1只公鸡，还能买多少只小鸡
         // 如果买2只母鸡，再买2只公鸡，还能买多少只小鸡
         // ...

         // 母鸡数量
         int i = 0;
         // 公鸡数量
         int j = 0;
         // 小鸡数量
         int k = 0;

         System.out.println("计算百钱百鸡问题的结果：");

         // while循环的嵌套
         // 注意：使用while循环的嵌套时，格外要注意内层while循环的循环条件；同时也要考虑到while循环的执行效率

         // 下句语句其实效率不高，可以改进
 //        while (i < 100) {    // 统计买母鸡的只数
         while (i < 20) {    // 统计买母鸡的只数
             // 注意：必须在后一次的内层循环之前，把变量j的值重新赋值一下，否则这个变量j的值还是上一次内层循环结束时得到的那个值
             j = 0;

             // 下句语句其实效率不高，可以改进
 //            while (j < 100) {    // 统计买公鸡的只数
             while (j < 33) {    // 统计买公鸡的只数
                 // 可以根据母鸡数量 和 公鸡数量 就可以得到小鸡数量
                 k = 100 - i - j;

                 // 根据思路分析中列出的等式
                 if ((5 * i + 3 * j + k / 3 == 100) && (k % 3 == 0) && (i != 0) && (j != 0) && (k != 0)) {
                     System.out.println("母鸡为：" + i + "只，公鸡为：" + j + "只，小鸡为：" + k + "只");
                 }

                 j++;
             }
             i++;
         }

     }
 }

 package cn.temptation;

 public class Sample11 {
     public static void main(String[] args) {
         // do...while循环（直到型循环）
         // 格式：
 //        do {
 //            System.out.println("直到型循环");
 //        } while (condition);

         int i = 1;

 //        do {
 //            System.out.println(i);
 //            i++;
 //        } while (i < 4);

         // while循环 和 do...while循环的区别：
         // 1、可以设置断点，结合调试分析
         //        while循环的条件写在最上面，一上来就先判断条件是否满足，满足了才会进入循环体执行语句
         //        do...while循环的条件写在最后，一上来就先进入循环体并执行循环体中的语句，再判断循环条件是否满足，满足的话继续循环
         //    注意：do...while循环在相同的条件（condition）不成立的情况下会比while循环多执行一次
         // 2、while结构就是一个语句块；do...while结构后必须要有一个分号，否则就产生语法错误

         // do...while循环在相同的条件（condition）成立的情况下和while循环的执行次数相同
         while (i < 3) {
             System.out.println(i);
             i++;
         }

         do {
             System.out.println(i);
             i++;
         } while (i < 3);

         // do...while循环在相同的条件（condition）不成立的情况下会比while循环多执行一次
         while (i < 1) {
             System.out.println(i);
             i++;
         }

         do {
             System.out.println(i);
             i++;
         } while (i < 1);
     }
 }

 package cn.temptation;

 public class Sample12 {
     public static void main(String[] args) {
         // 需求：使用do...while循环输出1~100之间的数字
         // 需求：使用do...while循环计算1+2+...+100和
         int i = 1;

         do {
             System.out.println(i);
             i++;
         } while (i <= 100);

         // 因为此时i == 101，所以需要把i进行重置
         i = 1;
         int sum = 0;

         do {
             sum += i;
             i++;
         } while (i <= 100);

         System.out.println("1+2+...+100=" + sum);
     }
 }

 package cn.temptation;

 public class Sample13 {
     public static void main(String[] args) {
         // 需求：使用do...while循环列出1~100之间所有的奇数
         int i = 1;

         // 写法1、奇数的间隔为2
 //        do {
 //            System.out.println(i);
 //            i += 2;
 //        } while (i <= 100);

         // 写法2、奇数是和2求余数为1的数字
         do {
             if (i % 2 == 1) {
                 System.out.println(i);
             }

             i++;
         } while (i <= 100);
     }
 }