【原】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);
    }
}