JAVA学习笔记三之(3)语句②

最新推荐文章于 2023-12-24 00:07:32 发布

Lucky_Light

最新推荐文章于 2023-12-24 00:07:32 发布

阅读量447

点赞数

分类专栏： JAVASE学习文章标签： java

本文链接：https://blog.csdn.net/Celelong/article/details/51489807

版权

JAVASE学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

JAVA学习笔记三之(3)语句②

一、for循环语句

　　１、循环到底应该包含哪些内容呢？
　　　　A：你要谁执行很多次呢？
　　　　　　循环体;
　　　　B：如何控制次数呢？
　　　　　　控制判断条件;
　　　　C：起始条件。
　　　　D：递增条件。

　　２、for循环的格式

class ForDemo1 {
    public static void main(String[] args) {
        //需求1：请在控制台输出5次"Hello World"
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("-----------");

        //需求2：请在控制台输出5000000次"Hello World"
        //通过简单的分析，我们知道知道这样的程序自己实现起来比较麻烦。
        //所以，考虑通过循环改进。

        /*
            for (初始化条件表达式; 控制条件表达式; 增量表达式) {
            循环体语句;
            }
        */

        //初始化表达式从0开始。
        for (int i = 0; i < 5; i++) {
            System.out.println("Hello World");
        }

        System.out.println("-----------");

        //初始化表达式从1开始。
        for (int j = 1; j <= 5; j++) {
            System.out.println("Hello World");
        }
    }
}

　　　　for (初始化条件表达式; 控制条件表达式; 增量表达式) {
　　　　　　循环体语句;
　　　　}

　　３、for循环的执行流程
　　　　A：首先执行初始化条件表达式。
　　　　B：其次执行控制条件表达式，看其返回值是：
　　　　　　true：执行循环体语句；继续执行增量表达式，然后回到B继续执行。
　　　　　　false：循环结束。继续执行for循环后面的语句。
　　　　
　　　　在整个循环的过程中：
　　　　　　初始化条件表达式：只执行一次。
　　　　　　控制条件表达式：执行1次到多次。
　　　　　　循环体语句和增量表达式：执行0次到多次。

　　４、小示例
　　　　(1)、输出10次”Hello World”
　　　　(2)、请输出1-10的数据
　　　　(3)、请输出10-1的数据

class ForDemo2 {
    public static void main(String[] args) {
        //输出10次"Hello World"
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello World");
        }

        System.out.println("--------------");

        //请输出1-10的数据
        for (int j = 1; j <= 10; j++) {
            System.out.println(j);
        }

        System.out.println("--------------");

        //请输出10-1的数据
        for (int k = 10; k > 0; k--) {
            System.out.println(k);
        }
    }
}

　　５、求出1-10之间的数据和。
　　　　分析：
　　　　　　A：由于我们想要获取1-10的和，所以，我们肯定要获取1-10的每一个数据。
　　　　　　　　而这个动作，用for循环最好。
　　　　　　B：思考下求和额度步骤
　　　　　　0+1=1
　　　　　　　　1+2=3
　　　　　　　　　　3+3=6
　　　　　　　　　　　　6+4=10
　　　　　　　　　　　　　　10+5=15
　　　　　　　　　　　　　　　　15+6=21
　　　　　　　　　　　　　　　　……
　　　　　　
　　　　通过简单的分析，我们发现了两个东西：
　　　　　　a：被加数是上一次的求和结果。
　　　　　　　　最原始的结果默认是0.
　　　　　　b：加数正好就是每一次获取到的值。
　　　　
　　　　由于被加数和加数都是变化的，所以，我们定义两个变量。

class  ForDemo3 {
    public static void main(String[] args) {
        //最基本的做法。但是，如果数据太大，就不好了。
        //System.out.println(1+2+3+4+5+6+7+8+9+10);
        //所以，考虑改进。

        //定义求和变量（被加数）
        int sum = 0;

        /*
        for (int i = 1; i <= 10; i++) {
            //i-1,2,3,4,5...
            //sum + i = sum;
            sum += i;
            //第一次：sum = 0 + 1 = 1;
            //第二次：sum = 1 + 2 = 3;
        }
        */

        //标准代码
        for (int i = 1; i <= 10; i++) {
            sum += i;
        }

        System.out.println(sum);
    }
}

　　６、求出1-100之间的偶数和。
　　
　　　　如何确定数据是偶数还是奇数呢？
　　　　　　任意一个数据x。
　　　　　　x%2 == 0 - - 偶数
　　　　　　x%2 == 1 - - 奇数

class ForDemo4 {
    public static void main(String[] args) {
        //定义求和变量

        //方式1
        /*
        int sum = 0;

        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }

        System.out.println("1-100之间的偶数和是：" + sum);
        */

        //方式2
        int sum = 0;

        for (int i = 0; i <= 100; i += 2) {
            sum += i;
        }

        System.out.println("1-100之间的偶数和是：" + sum);
    }
}

　　７、求1*2*3*4*5的结果。（1求5的阶乘，n的阶乘 = 1*2*3*4*5*…*n）

class ForDemo5 {
    public static void main(String[] args) {
        //定义求乘积结果变量
        int result = 1;

        //获取1-5的数据
        for (int i = 1; i <= 5; i++) {
            result *= i;
        }

        System.out.println(result);
    }
}

　　８、打印出所有的“水仙花数”。

　　　　所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数字本身。
　　　　
　　　　例如：
　　　　　　153是一个“水仙花数”，因为153=1的三次方+5的三次方+3的三次方。

　　　　分析：
　　　　　　A：所谓“水仙花数”是指一个三位数。告诉我们“水仙花数”的范围。100-999
　　　　　　B：如何获取各位，十位，百位上的每一个数据？
　　　　　　　　假设我有一个任意的数据x。
　　　　　　　　　　个位：x%10
　　　　　　　　　　十位：x/10%10
　　　　　　　　　　百位：x/10/10%10
　　　　　　　　　　千位：x/10/10/10%10
　　　　　　　　　　……
　　　　　　C：判断
　　　　　　　　if (x == 个位的三次方 + 十位的三次方 + 百位的三次方) {
　　　　　　　　　　System.oit.println(x);
　　　　　　　　}

class ForDemo6 {
    public static void main(String[] args) {
        //通过for循环实现获取范围的数据
        for (int x = 100; x < 1000; x++) {
            //通过取余和除法得到个，十，百位上的数据
            int ge = x%10;
            int shi = x/10%10;
            int bai = x/100;

            //判断
            if (x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                System.out.println(x);
            }
        }
    }
}

　　９、请输出满足条件的五位数。
　　　　　　以下的条件要同时满足：
　　　　　　　　个位=万位
　　　　　　　　十位=千位
　　　　　　　　个位+十位+千位+万位=百位

　　　　分析：
　　　　　　A：五位数告诉我们范围：10000-99999
　　　　　　B：获取个，十，百，千，万对应的数据
　　　　　　C：根据条件判断

　　　　变量的作用域：
　　　　　　变量只在它所属的那对大括号之内有效。

class ForDemo7 {
    public static void main(String[] args) {
        for (int i = 10000; i < 99999; i++) {
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;
            int qian = i/10/10/10%10;
            int wan = i/10/10/10/10%10;

            if ((ge == wan) && (shi == qian) && (ge + shi + qian + wan == bai)) {
                System.out.println(i);
            } 
        }
    }
}

　　10、请编写程序输出1-1000之内的这样的数据。
　　　　有这样的数据，对3整除余2，对5整除余3，对7整除余2。

　　　　分析：
　　　　　　A：1-1000告诉我们了范围。用for循环实现。
　　　　　　B：条件要同时满足：
　　　　　　　　对3整除余2，对5整除余3，对7整除余2。

class ForDemo9 {
    public static void main(String[] args) {
        //1-1000告诉我们了范围。用for循环实现。

        for (int i = 1; i <= 1000; i++) {
            if (i%3==2 && i%5==3 && i%7==2) {
                System.out.println(i);
            }
        }
    }
}

二、while循环和do_while循环

　　１、while循环的格式
　　　　格式：
　　　　　　while (条件表达式) {
　　　　　　　　语句;
　　　　　　}

　　　　扩展格式：
　　　　　　初始化条件表达式;
　　　　　　while (控制条件表达式) {
　　　　　　　　循环体语句;
　　　　　　　　增量表达式;
　　　　　　}
　　　　
　　　　while循环可以和for循环进行等价转换。
　　　　之前的所有for循环案例都可以采用while循环改进。

class WhileDemo1 {
    public static void main(String[] args) {
        //输出10个Helllo World
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello World");
        }

        System.out.println("-------------");

        int i = 0;
        while (i < 10) {
            System.out.println("Hello World");
            i++;
        }
    }
}

　　２、for循环和while循环的区别
　　　　(1)、区别是什么呢？
　　　　　　增量的那个变量的值，for循环外面不可以继续使用。而while循环外面的可以继续使用。
　　　　　　推荐使用for循环。
　　　　　　
　　　　(2)、应用场景的区别？
　　　　　　如果是一个范围的操作，用for循环。
　　　　　　如果要做一个动作多少次的次数不明确，用while循环。
　　　　　　　　举例：吃葡萄。

// 水仙花案例。
class WhileDemo2 {
    public static void main(String[] args) {
        //for循环
        for (int i = 100; i < 1000; i++) {
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;'

            if (i == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                System.out.println(i);
            }
        }

        System.out.println("----------------------");

        //while循环改进
        int i = 100;
        while (i < 1000) {
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;'

            if (i == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                System.out.println(i);
            }

            i++;
        }

        /*
        //这个时候，这个i就不能再定义了。
        for (int i = 100; i < 1000; i++) {
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;'

            if (i == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                System.out.println(i);
            }
        }
        */
    }
}

　　３、while循环的示例
　　　　问题：我国最高的山峰是珠穆朗玛峰：8848m。
　　　　　　　我有一张足够大的纸张，厚度：0.01m。
　　　　　　　请问，我折叠多少次就可以不低于珠穆朗玛峰的高度。

　　　　分析：
　　　　　　A：结果要输出折叠的次数，所以要定于一个统计变量。初始值是0.
　　　　　　B：一些知道的条件
　　　　　　　　double start = 0.01;
　　　　　　　　double end = 8848;
　　　　　　C：规律：
　　　　　　　　每次折叠，厚度就是以前的两倍。

class WhileDemo3 {
    public static void main(String[] args) {
        //定义统计变量
        int count = 0;

        //定于初始化值
        double start = 0.01;
        double end = 8848;

        //判断
        while (start < end) {
            //统计
            count++;

            //折叠的厚度
            start *= 2;
        }

        System.out.println(count);

        System.out.println("----------------------");

        //用for循环改进
        count = 0;

        for (double x = 0.01, y = 8848; x < y; x *= 2) {
            count++; 
        }

        System.out.println(count);
    }
}

　　４、do_while循环的格式
　　　　(1)、基本格式：
　　　　　　do {
　　　　　　　　语句体;
　　　　　　}while(判断条件);

　　　　(2)、扩展条件：
　　　　　　初始化条件表达式;
　　　　　　do {
　　　　　　　　循环体语句;
　　　　　　　　增量表达式;
　　　　　　}While(控制条件表达式);

class DoWhileDemo {
    public static void main(String[] args) {
        //用do_while实现输出10次Hello World
        int x = 0;

        do {
            System.out.println("Hello World");
            x++;
        }while (x < 10);

        System.out.println("--------------");

        //do_while循环和while循环以及for循环的区别？
        int y = 3;

        do {
            System.out.println("今天天气很好，我很高兴。");
            y++;
        }while (y < 3);

        System.out.println("--------------");

        //用while循环
        int z = 3;

        while (z < 3) {
            System.out.println("今天天气很好，我很高兴。");
            z++;
        }
    }
}

三、for循环的嵌套

　　１、需求：请输出如下形状。
　　　　　　　* * * * *
　　　　　　　* * * * *
　　　　　　　* * * * *
　　　　　　　* * * * *
　　　　输出格式：
　　　　　　System.out.print(“内容”); //输出内容，没有换行。
　　　　　　System.out.println(“内容”); //输出内容后，加了一个换行符。
　　　　　　
　　　　如何单独实现一个换行，不做任何输出呢？
　　　　　　System.out.println();
　　　　
　　　　这种程序用双层循环就可以搞定。
　　　　而且：
　　　　　　A：外循环执行一次，内循环执行多次。
　　　　　　B：外循环控制行数，内循环控制列数

class ForForDemo1 {
    public static void main(String[] args) {
        //我要是能够输出一颗*就好了
        //System.out.print("*");
        //System.out.println("*");
        //System.out.println();

        //一次输出一颗*
        /*
        System.out.print("*");
        System.out.print("*");
        System.out.print("*");
        System.out.print("*");
        System.out.print("*");
        */

        //由于做了5次一模一样的操作，所以，我们考虑通过循环改进
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }

            System.out.println();
        }
    }
}

　　２、输出如下形状：
　　　　　　*
　　　　　　* *
　　　　　　* * *
　　　　　　* * * *
　　　　　　* * * * *

class ForForDemo2 {
    public static void main(String[] args) {
        //看到在这个形状，我们首先输出一个5行5列的星星。
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("------------");

        //而我们想要的是依次列数变化的。
        //由于内循环控制列，所以，内循环应该是一个变化的，而不是一个固定的值。
        //第一行：1列    j = 0, j <= 0
        //第二行：2列    j = 0, j <= 1
        //第三行：3列    j = 0, j <= 2
        //第四行：4列    j = 0, j <= 3
        //第五行：5列    j = 0, j <= 4
        //我们发现，这个程序就可以改进为最终版

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

　　３、输出九九乘法表。
　　　　1*1=1
　　　　1*2=2 　2*2=4
　　　　1*3=3 　2*3=6　3*3=9
　　　　…
　　　　1*9=9 　2*9=18　3*9=27 　4*9=36　…　8*9=72 　9*9=81

　　　　转义字符：
　　　　　　\t：一个制表符。相当于按了一个tab。

class ForForDemo3 {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i*j + "\t");
            }

            System.out.println();
        }
    }
}

四、continue和break的使用

　　１、continue和break的效果
　　　　continue：必须使用在循环之中。结束本次循环，进入下一次循环。
　　　　break：用在switch语句和循环中。结束当前循环。
　　
　　　　注意：
　　　　　　continue和break不能单独使用。

class ContinueAndBreakDemo {
    public static void main(String[] args) {
        //需求：请输出1-10的数据
        for (int i = 0; i < 10; i++) {
            System.out.println(i+1);
        }

        System.out.println("------------------------");

        for (int j = 1; j <= 10; j++) {
            if (j % 2 == 0) {
                continue; //执行这里了，结束本次循环，继续下次循环的执行。
            }
            System.out.println(j); //1, 3, 5, 7, 9
        }

        System.out.println("------------------------");

        for (int j = 1; j <= 10; j++) {
            if (j % 2 == 0) {
                break; //执行这里了，结束当前循环。
            }
            System.out.println(j); //1, 3, 5, 7, 9
        }

        System.out.println("over");
    }
}

　　２、带标号的退出。
　　　　看程序：
　　　　　　break只能结束它当前所在的那一层循环。
　　　　　　
　　　　那么，双层循环嵌套该如何退出呢？
　　　　　　带标号的退出。

class ContinueAndBreakDemo2 {
    public static void main(String[] args) {
        wc:for (int i = 0; i < 3; i++) {
            nc:for (int j = 0; j < 4; j++) {
                if (j % 2 == 1) {
                    break wc;
                }
                System.out.println("#");
            }
            System.out.println();
        }

        System.out.println("over");
    }
}