Java语言基础-图解流程控制加全套练习题(保姆级教学)

最新推荐文章于 2022-05-26 19:23:44 发布
最新推荐文章于 2022-05-26 19:23:44 发布
阅读量597 收藏 2
点赞数 1
分类专栏： ▶寒暄_Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41106844/article/details/105844557
版权

流程控制

我们来想一个工厂的生产销售过程，从接单，物料的进厂，上线，加工过程1，加工过程2，加工过程3，包装，下线，出厂，进仓库，转运，售出。这是一整套的流程，而且每个阶段都是可以人为设置更改的，这就是人对这套流程的流程控制。例如在加工过程1中，只要符合规格的物料；在包装中，有的用红色包装，有的用蓝色包装；例如在加工过程3中，要重复进行三次等等。

在整套流程中，每个环节按照顺序依次执行，这对应着程序开发中的顺序结构；在包装中，有的用红色包装，有的用蓝色包装，对应着程序开发中的分支结构；还有需要重复三次，对应着程序开发中的循环结构。

  • 顺序结构

    程序从上到下逐行进行执行，中间没有任何判断和跳转。

  • 分支结构

    根据条件，选择性的执行某段代码。

    有if…else和switch…else两种分支语句。

  • 循环结构

    根据循环条件，重复性的执行某段代码

    有while、do…while、for三种循环语句

顺序结构

在这里插入图片描述

class OrderTest {
    public static void main(String[] args) {
        System.out.println("进厂");
        System.out.println("加工");
        System.out.println("出厂");
    }
}

分支结构

if语句

语法：

if(条件表达式){
	执行代码块
}

在这里插入图片描述

class BranchTest {
    public static void main(String[] args) {
        // if
        int success = 85;
        if(success > 80){
            System.out.println("成绩为优秀");
        } 
    }
}
if-else语句

语法：

if(条件表达式){
	执行代码块1
}else{
	执行代码块2
}

在这里插入图片描述

class BranchTest {
    public static void main(String[] args) {
        // if-else
        if(success < 60){
            System.out.println("没有及格");
        }else{
            System.out.println("及格了！");
        }      
    }
}
if-else if-else

语法：

if(条件表达式1){
	执行代码块1
}else if(条件表达式2){
	执行代码块2
}else if(...){
	...
}else if(条件表达式N){
	执行代码块N
}else{
	执行代码块N+1
}

在这里插入图片描述

class BranchTest {
    public static void main(String[] args) {
        // if-else if-else
        if(success >= 90){
            System.out.println("成绩很好，很棒！");
        }else if((80 <= success) && (success < 90 )){
            System.out.println("成绩很不错，但是还有提升的空间！");
        }else if((60 <= success) && (success < 80 )){
            System.out.println("还可以，但是要努力加油了！");
        }else{
            System.out.println("你现在很危险！");
        }
        
    }
}

然后来做几道练习题：

class BranchTest1 {
    public static void main(String[] args) {
	    // 练习1
        int x = 4;
        int y = 1;
        if(x > 2){
            if(y > 2)
                // 这一条不会输出，是因为if语句有一种特殊的原则叫做就近原则
                // 这一条语句属于 if(y > 2)。
                System.out.println(x + y);     
                // 就近原则只对第一行有约束作用
                // 这一条语句属于 if(x > 2)   
                System.out.println("红鲤鱼绿鲤鱼");
        }else{
            System.out.println("x is" + x);
        }
        // 总结： 不要省略大括号，会影响代码可读性

        // 练习2
        boolean b = true;
        if(b == false)
            System.out.println("a");
        else if(b)
            System.out.println("b"); // 匹配到第一条表达式为true的语句就不再往下匹配。
        else if(b)
            System.out.println("c");    
        else
            System.out.println("d");

        // 练习3
        /*
         * 编写程序，声明2个int型变量并赋值，
         * 判断两数之和，如果大于等于50，打印"Hello World!" 
        */
        int lx3A = 30;
        int lx3B = 30;
        if (lx3A + lx3B >=50){
            System.out.println("Hello World!");
        }


        // 练习4
        /*
         * 编写程序，声明2个double型变量并赋值。
         * 判断第一个数大于10.0，且第二个数小于20.0，
         * 打印两数之和。
         * 否则打印两数之积。 
        */ 
        double lx4A = 12.34;
        double lx4B = 12.45;
        if (lx4A > 10 && lx4B < 20){
            System.out.println(lx4A + lx4B);
        }else{
            System.out.println(lx4A * lx4B);
        }
 	}
 }

键盘输入

如果只通过单纯的分支结构，显然过于僵硬，输入什么，输出什么都是僵硬的，那么可不可以控制输入来影响输出。这就需要扫描类–scanner。

import java.util.Scanner;

class InputTest {
    public static void main(String[] args) {
        /*
         * 岳小鹏参加考试，他爸爸和他说： 
         * 考100分，奖励一个手机； 
         * 考80到99分，奖励一个平板； 
         * 考60到80分，奖励一个主机游戏； 
         * 其他分数就什么也不奖励。
         * 
         * 请使用键盘输入岳小鹏的成绩进行判断。
         * 
         * 如何进行键盘输入呢？ 需要使用Scanner类
         * 
         * 1. 导包 impart java.util.Scanner; (写在类外) 
         * 2. 实例化对象 Scanner scan = newScanner(System.in); (System.in 表示从键盘输入)(写在main内) 
         * 3. 调用整型接收成绩 int success = scan.nextInt(); (获取指定类型的变量) (写在需要接收输入的地方)
         */
        Scanner scan = new Scanner(System.in);
        System.out.println("岳小鹏，你考了多少分呢？");
        int success = scan.nextInt();
        if(success == 100){
            System.out.println("岳小鹏获得了一个*为 Mate30 RS 5G版");
        }else if(80<=success && success<=99){
            System.out.println("岳小鹏获得了一个*为 MatePad Pro");
        }else if(60<=success && success<80){
            System.out.println("岳小鹏获得了只狼一部，并戒除游戏考上了清华");
        }else{
            System.out.println("屁也没有");
        }
        
        // 释放内存流
        scan.close();
    }
}

scanner除了nextInt这个函数之外，还有什么函数呢？

import java.util.Scanner;

class ScannerTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        
        System.out.println("请输入你的姓名");
        String name = scan.next();
        
        System.out.println("请输入你的年龄");
        int age = scan.nextInt();
        // nextByte 接收byte，nextShort 接收short，以此类推
        
        System.out.println("请输入你的体重");
        // 这里也一样
        double weight = scan.nextDouble();
        
        System.out.println("你是否单身");
        boolean isOk = scan.nextBoolean();

        System.out.println("姓名是： " + name);
        System.out.println("年龄是： " + age);
        System.out.println("体重是： " + weight);
        System.out.println("是否单身： " + isOk);
    

        scan.close();

        // 如果输入的类型与接收的类型不匹配时，会报异常：InputMismatchException
    }
}

现在，结合键盘录入类Scanner做几道if-else if-else的练习题

import java.util.Scanner;

class InputTest1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    	// 练习1
        /*
         *由键盘输入三个整数，分别存储num1，num2，num3，对他们进行排序（使用 if-else if-else）,并从小到大输出。  
         */
        System.out.println("请输入num1：");
        int num1 = scan.nextInt();
        System.out.println("请输入num2：");
        int num2 = scan.nextInt();
        System.out.println("请输入num3：");
        int num3 = scan.nextInt();
        if(num1 >= num2){
            if (num3 >= num1){
                System.out.println(num2+","+num1+","+num3);
            }else if(num3 <= num2 ){
                System.out.println(num3+","+num2+","+num1);
            }else{
                System.out.println(num2+","+num3+","+num1);
            }
        }else{
            if (num3 >= num2){
                System.out.println(num1+","+num2+","+num3);
            }else if(num3 <= num1 ){
                System.out.println(num3+","+num1+","+num2);
            }else{
                System.out.println(num1+","+num3+","+num2);
            }
        }

        // 练习2
        /* 
         * 狗的年龄与人的年龄换算：
         * 狗的前两年一年相当于人的10.5岁
         * 之后每一岁相当于人的四岁。 
         * 编写一个程序，获取用户输入狗的年龄
         * 通过程序展示对应人类的年龄。
         * 如果输入负值，显示一个提醒。
        */

        System.out.print("请输入狗的年龄：");
        double lx5Age = scan.nextDouble();
        if (lx5Age >= 0 && lx5Age <=2){
            lx5Age = lx5Age * 10.5;
            System.out.println("相当于人类的"+lx5Age+"岁");       
        }else if(lx5Age > 2){
            lx5Age = 21 + (lx5Age - 2) * 4;
            System.out.println("相当于人类的"+lx5Age+"岁");
        }else{
            System.out.println("请输入大于等于0的数字");
        }

        scan.close();
    }
}

然后再多来一道附加题：

假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
（1）如果用户输入的数匹配彩票的实际顺序，奖金10000元
（2）如果用户输入的所有数字匹配彩票的所有数字，奖金3000元
（3）如果用户输入的一个数字仅满足顺序的情况下匹配彩票的一个数字，奖金1000元
（4）如果用户输入的一个数字仅满足非顺序的情况下匹配彩票的一个数字，奖金500元
（5）若不匹配，彩票作废。

例如，随机生成一个数字：45
用户输入45，则奖金10000元。
用户输入54，则奖金3000元。
用户输入4*或*5，则奖金1000元。
用户输入*4或5*，则奖金500元。
其他情况彩票作废。

首先，要解决一个问题：怎么生成随机数？

生成随机数

如何获得一个随机数，就需要用到另外的一个类：Math。

import java.util.Scanner;

class RandomTest {
    public static void main(String[] args) {
        // 首先随机生成一个两位数
        // Math位于java.lang包下，此包下的所有类不需要impost引入
        int number = (int)(Math.random() * 90 + 10);    
        // Math.random() 会随机生成一个位于[0,1)的数
        // Math.random() * 90 + 10 会生成一个[10,100)的数

        // 得到随机数的十位和个位
        int numberShi = number/10;
        int numberGe = number%10;
        
        // 用户输入一个两位数
        Scanner input = new Scanner(System.in);
        System.out.print("请输入一个两位数：");
        int guess = input.nextInt();
    
        // 获取用户输入数的十位和个位
        int guessShi = guess/10;
        int guessGe = guess%10;
            
        if(number == guess){
            System.out.println("奖金10 000元");
        }else if(numberShi == guessGe && numberGe == guessShi){
            System.out.println("奖金3 000元");
        }else if(numberShi==guessShi || numberGe == guessGe){
            System.out.println("奖金1 000元");
        }else if(numberShi==guessGe || numberGe == guessShi){
            System.out.println("奖金500元");
        }else{
            System.out.println("没中奖");
        }
        
        System.out.println("中奖号码是：" + number);

        input.close();
    }
}

OK，现在把视线放到我们最开始if-else if-else举得那个例子那里，现在我们有了另外一个需求：

100分的评分为S；

90-99分评分为A；

60分以下为D-；

以此类推。

如果使用if语句的话：

if(x == 100){
	System.out.println("S");
}else if(x>=90 && x<100){
	System.out.println("A");
}else if(x>=80 && x<90){
	System.out.println("B");
}else if(...){
	...
}else{
	System.out.println("请输入1-100");
}

难道要写这么多个else if吗，有没有简单一点的方法，这就可以用到另外一个分支语句–switch-case语句。

switch-case
switch(表达式){
	case 常量1:
		语句1;
		// break;
    case 常量2:
    	语句2;
    	// break;
    ...
    case 常量N:
    	语句N;
    	// break;
   	default:
   		语句N+1;
   		// break;
}

在这里插入图片描述

然后使用switch-case语句来实现成绩评分：

import java.util.Scanner;

class SwitchTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        int number = scan.nextInt();
        int numberGe = number / 10;
        switch(numberGe){
            case 10:
                System.out.println("评分为S");
                break;
            case 9:
                System.out.println("评分为A");
                break;
            case 8:
                System.out.println("评分为B");
                break;
            case 7:
                System.out.println("评分为C");
                break;
            case 6:
                System.out.println("评分为D");
                break;
            default:
                System.out.println("评分为D-");
        }

        scan.close();
    }
}

注意点1：case语句块后不加break的话会导致一旦匹配某一条case语句，就会开始执行从这条语句块之后的所有语句块，直到遇到break或switch语句块结尾。

例如：输入70，应该输出评分C，但是如果将break都注释掉，则会输出：

评分为C
评分为D
评分为D-

注意点2：switch表达式只能是：byte，short，int，char，枚举类型和string。

注意点3：case后必须跟常量

注意点4：default可选，且位置可控，如果不在末位的话，记得要加break

练习题：

import java.util.Scanner;
class SwitchTest1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        /**
         * 1.使用是switch把小写类型的char型转为大写，
         * 只转换a,b,c,d,e,其他的输出‘other’
         */
        System.out.println("请输入字母：");
        String word = scan.next();
        char c = word.charAt(0);
        switch(c){
            case 'a':
                c = 'A';
                break;
            case 'b':
                c = 'B';
                break;
            case 'c':
                c = 'C';
                break;
            case 'd':
                c = 'D';
                break;
            case 'e':
                c = 'E';
                break;
            default:
                System.out.println("other");
        }
        System.out.println(c);

        /**
         * 2.根据指定月份，打印该月份所属的季节。
         */
        System.out.println("请输入月份：");
        int month = scan.nextInt();
        switch(month){
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("请输入1-12");
        }
    
        /**
         * 3.从键盘上输入2020年的月和日，
         * 然后输出输入日期为2020年的第几天。
         */
        System.out.println("请输入月份：");
        int lx3Month = scan.nextInt();
        System.out.println("请输入日期：");
        int lx3Day = scan.nextInt();
        int sumDays = 0;
        switch(lx3Month){
            case 12:
                sumDays += 30;
            case 11:
                sumDays += 31;
            case 10:
                sumDays += 30;
            case 9:
                sumDays += 31;  
            case 8:
                sumDays += 31;               
            case 7:
                sumDays += 30;
            case 6:
                sumDays += 31; 
            case 5:
                sumDays += 30;
            case 4:
                sumDays += 31;  
            case 3:
                sumDays += 29;
            case 2:
                sumDays += 31; 
            case 1:
                sumDays += lx3Day;
            default:
                System.out.println("请输入1-12");
        }
        System.out.println(sumDays);

        scan.close();
    }
}

循环结构

for语句

语法：

for(初始化条件;循环条件;迭代条件){
	循环体
}

在这里插入图片描述

去看一下最开始的工厂流程，加工过程3要重复执行三次，现在我们来简化成代码，如果不使用循环结构的话，也许可以这样写：

class ForTest {
    public static void main(String[] args) {
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        System.out.println("Hello World!");
    }    
}

如果使用循环结构的话：

class ForTest {
    public static void main(String[] args) {
        for(int i = 0;i < 3;i ++){
            System.out.println("Hello World!");
        }
    }    
}

练习题：

import java.util.Scanner;

class ForTest {
    public static void main(String[] args) {
        /**
         * 练习1
         * 写出这段程序的运行结果，
         * 以来理解for循环的执行流程
         */
        int num = 1;
        for (System.out.println('a');num <= 3;System.out.println('c'),num ++){
            System.out.println('b');
        }

        /**
         * 练习2
         * 遍历100以内的偶数
         */
        for(int a = 0;a <= 100; a += 2){
            System.out.println(a);
        }

        /**
         * 练习3
         * 循环输出1-150，每一行打印一个值，
         * 3的倍数后打印foo
         * 5的倍数后打印biz
         * 7的倍数后打印baz
         * 注：可以重复追加
         */
        
        for(int b = 1;b <= 150;b ++){
            String s = b + "";
             if (b % 3 == 0){
                 s += " foo";
             }
             if (b % 5 == 0){
                 s += " biz";
             }
             if (b % 7 == 0){
                 s += " baz";
             }
             System.out.println(s);
        } 

        /**
         * 练习4
         * 输入两个正整数m和n，求其最大公约数和最小公倍数
         * 12和20的最大公约数是4，最小公倍数是60
         */
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入第一个正整数：");
        int m = scan.nextInt();

        System.out.println("请输入第二个正整数：");
        int n = scan.nextInt();
        
        for(int lx4i = Math.min(m, n);lx4i >= 1 ;lx4i -- ){
            if(m % lx4i == 0 && n % lx4i == 0){
                System.out.println("最大公约数：" + lx4i);
                break;
            }
        }
        for (int lx4j = Math.max(m, n);lx4j <= m * n;lx4j ++ ){
            if(lx4j % m == 0 && lx4j % n == 0){
                System.out.println("最小公倍数：" + lx4j);
                break;
            }
        }
        
        /**
         * 练习5
         * 打印1-100之间的奇数和
         */
        int sum = 0;
        for(int lx5I = 1;lx5I <= 100;lx5I += 2){
            sum += lx5I;
        }
        System.out.println("1-100奇数和为：" + sum);

        /**
         * 练习6
         * 打印1-100之间所有是7的倍数的整数的个数与和
         */
        int number = 0;
        sum = 0;
        for(int lx6I = 0; lx6I <= 100;lx6I ++){
            if(lx6I % 7 == 0){
                number ++;
                sum += lx6I;
            }
        }
        System.out.println("和为：" + sum);
        System.out.println("个数为：" + number);


        /**
         * 练习7
         * 输出1000以内所有的水仙花数。
         * 例如：153=1^3+5^3+3^3
         */
        for(int lx7I = 100;lx7I < 1000;lx7I ++){
            int lx7Ibai = lx7I / 100;
            int lx7Ishi = lx7I % 100 /10;
            int lx7Ige = lx7I % 10;
            if (lx7Ibai*lx7Ibai*lx7Ibai+lx7Ishi*lx7Ishi*lx7Ishi+lx7Ige*lx7Ige*lx7Ige == lx7I ){
                System.out.println(lx7I);
            }
        
        }
        scan.close();
    }    
}

到这里，大家对for循环有了初步的理解，接着我们来仔细说一下break语句以及他的孪生兄弟continue语句。

break和continue

break可以用在switch-case语句和循环结构中，可以终止所在语句块的执行，跳转到语句块外。

continue比break温柔一些，他只能作用在循环结构中，并且只能终止当前循环。

来看一下他们的执行图
在这里插入图片描述

在这里插入图片描述

然后看两个例子：

class ContinueTest {
    public static void main(String[] args) {
        for(int i = 0;i < 5;i ++ ){
            if(i == 3){
                break;
            }
            System.out.println(i);
        }
        System.out.println("-----");
        for(int j = 0;j < 5;j ++ ){
            if(j == 3){
                continue;
            }
            System.out.println(j);
        }
    }    
}
0
1
2
-----
0
1
2
4

break和continue语句还有一个名称，叫做循环控制语句，他们可以控制循环是否进行。

现在我们可以产生循环结构，可以控制循环结构了，那么我们是不是可以写一个无限的循环呢，只让他在特定的情况下结束循环。比如我们在上面写过一个猜彩票的小游戏，它允许一次只可以玩一次，那么该怎么让我们可以无限玩呢？

这就需要我们另一个循环语句–while语句。

while语句

语法：

初始化条件
while(条件表达式){
	循环体;
	迭代条件;
}

他的执行流程与for循环的执行流程一致，就不重复了。

class WhileTest {
    public static void main(String[] args) {
        int i = 5;                  // 初始化条件
        while(i >= 0){              // 条件表达式
            System.out.println(i);  // 循环体
            i --;                   // 迭代条件
        }
    }    
}

然后我们来看看最开始所说的while循环具有的特性：

import java.util.Scanner;
class WhileTest {
    public static void main(String[] args) {                  
        Scanner scan = new Scanner(System.in);
        int i = 0;
        while(true){              
            System.out.println("请输入一个数：");  
            i = scan.nextInt();
            if (i == 10){
                break;
            }
        }
        scan.close();
    }    
}

这样的话，只有我们输入10，这个循环才会结束，否则会一直执行。

然后改进一下我们的猜彩票小游戏，改成猜数小游戏。

import java.util.Scanner;

class WhileTest1 {
    public static void main(final String[] args) {
        // 首先随机生成一个两位数
        final int number = (int)(Math.random() * 90 + 10);    

        // 实例化对象
        Scanner input = new Scanner(System.in);
        
        int guess = 0;
        int num = 0;
        
        while(true){
            num ++;

            System.out.print("请输入一个两位数：");
            guess = input.nextInt();
            
            if(guess == number){
                System.out.println("恭喜你猜对了，你一共猜了"+num+"次!");
                break;
            }else if(guess > number){
                System.out.println("你猜大了!");
            }else{
                System.out.println("你猜小了!");
            }

        }
        input.close();
    }
}

然后，while语句还有一个兄弟-do–while语句。

do–while语句

语法：

初始化条件;
do{
	循环体;
	迭代条件;
}while(条件表达式)

这个语句的条件表达式是放在最后的，也就是说第一次循环体的执行无序进行条件判断。

在这里插入图片描述

流程图也是独具一格，不过太特殊的东西一般用的都不多，这里就不再细细阐述，就需要记住他无论满不满足条件表达式都可以执行一次循环体。

嵌套循环

嵌套不是一个新的知识点，在说if语句时我们就使用过在if中嵌套if的用法。

嵌套循环也就是把一个循环语句放到另一个循环语句中。

class NestedLoop{
    public static void main(String[] args) {
        for(int i = 0;i < 5;i ++){
            for(int j = 0;j < 3;j ++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

或者

class NestedLoop{
    public static void main(String[] args) {
        int a = 0;
        while(a < 5){
            int b = 0;
            while(b < 3){
                System.out.print("* ");
                b ++;
            }
            System.out.println();
            a ++;
        }
    }
}

还有

class NestedLoop{
    public static void main(String[] args) {
        int x = 0;
        do{
            int y = 0;
            do{
                System.out.print("* ");
                y ++;
            }while(y < 3);
            System.out.println();
            x ++;
        }while(x < 5);
    }
}

这几个看起来，果然还是for循环的可读性更高。

然后写个九九乘法表：

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

外层循环控制行数，内层循环控制列数。

然后我们用“*”打印一个菱形。

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

----------

class NestedLoop{
    public static void main(String[] args) {
		// 上半部分
		for (int i = 0; i < 5; i++) {
			// 输出“-”
			for (int j = 0; j < 4 - i; j++) {
				System.out.print(" ");
			}

			// 输出“* ”
			for (int k = 0; k < i + 1; k++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		// 下半部分
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < i + 1; j++) {
				System.out.print(" ");
			}
			for (int k = 0; k < 4 - i; k++) {
				System.out.print("* ");
			}
			System.out.println();

		}
    }
}

练习题:

class NestedLoop{
    public static void main(String[] args) {
        /**
         * 练习1
         * 输出1-100以内所有的质数
         * 思路：这个数模除1-它本身之间所有的数，都有余数的就是质数。
         */
        
        boolean  isFlag;  //引入旗值的概念。
        for(int lx1I = 2;lx1I <= 100;lx1I ++){
            isFlag = true;// 旗值默认为true
            for(int lx1J = 2;lx1J < lx1I;lx1J ++){
                if (lx1I % lx1J == 0){
                    isFlag = false;  // 如果有可以完全模除的数，就把旗值改为false
                }
            } 
            if(isFlag){ // 最后判断旗值是不是true，是的话表示没有可以完全模除的数
                System.out.println(lx1I);
            }
        }
        /**
         * 练习2
         * 输出1-100以内所有的完数
         * 完数就是一个数所有的因子相加等于这个数
         * 例如：6的因子是1,2,3  1+2+3 等于 6
         */
        for(int lx2I = 1;lx2I <= 1000;lx2I ++){
            int factor = 0;	// 使用一个变量来对待测数的因子进行加和。
            for(int lx2J = 1;lx2J <= lx2I / 2 ;lx2J ++){
            
                if(lx2I % lx2J== 0){
                    factor += lx2J;
                }
            }
        
            if(lx2I == factor){	// 如果加和后的数等于待测数，表示这个数是完数。
                System.out.println(lx2I);
            }
            
        }
    }
}

引入旗值这个概念可以很方便的理解，但是如果范围太大，这个代码运行的时间就太长了，时间复杂度是O(n2),空间复杂度是O(1)。

现在尝试对他进行一些优化,降低他的运行的时间：

boolean  isFlag;  //引入旗值的概念。
for(int lx1I = 2;lx1I <= 100;lx1I ++){
	isFlag = true;// 旗值默认为true
	for(int lx1J = 2;lx1J < lx1I;lx1J ++){
		if (lx1I % lx1J == 0){
        	isFlag = false;  // 如果有可以完全模除的数，就把旗值改为false
            break;	// 只需要增加一个break，也就是说只要旗值变了一次，就没必要进行下面的循环了
        }
    } 
    if(isFlag){ // 最后判断旗值是不是true，是的话表示没有可以完全模除的数
    	System.out.println(lx1I);
    }
}

优化二：

boolean  isFlag;  //引入旗值的概念。
for(int lx1I = 2;lx1I <= 100;lx1I ++){
	isFlag = true;// 旗值默认为true
	for(int lx1J = 2;lx1J <= Math.sqrt(lx1I);lx1J ++){  // 对数开方后，主要对最小因数进行遍历
		if (lx1I % lx1J == 0){
        	isFlag = false;  // 如果有可以完全模除的数，就把旗值改为false
            break;	// 只需要增加一个break，也就是说只要旗值变了一次，就没必要进行下面的循环了
        }
    } 
    if(isFlag){ // 最后判断旗值是不是true，是的话表示没有可以完全模除的数
    	System.out.println(lx1I);
    }
}

补充：循环控制语句的标签用法

循环控制语句可以搭配标签语句，在跳出时会自动跳到标签所在的位置,类似于goto语句。

label:for(int i = 1;i <= 4;i ++){
	for(int j = 1;j <= 10;j ++){
		if(j % 4 == 0){
			break label;
		}
		System.out.print(j);
	}
	System.out.println();
}

这样在执行break的时候，直接把外层循环也kill掉了。

continue同理。

寒 暄
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 流程控制15道练习题（选择&循环）
yinying293的博客
01-03 2676
Java练习题：15道流程控制道练习题（if、switch、for、while、do..while、嵌套）
java流程控制——30练习题（6-10题）
MoerPerfect的博客
05-19 424
6、赌数游戏。提供三个1-6的随机数，作为掷骰子得到的点数。如果各个点数相同，则为豹子。如果三个骰子点数和，小于或等于9，则为“小”。如果三个骰子点数和，大于9，则为“大”。用户随机选择：押大、押小或者押豹子。通过判断，输出客户是否押正确。7、生肖问题：编写一个程序，为一个给定的年份找出其对应的中国生肖。8、打印1-100之间13的倍数，使用for循环。9、用for循环计算1000以内偶数的和。10、1)输入长和宽，输出长方形，输出直角三角形，输出倒直角三角形，输出等腰三角形。
一个流程图例子，很好的。
java开发指南博客 【转载】
04-01 597
java流程控制练习题
weixin_45956838的博客
04-02 436
选择 1.C 2.B 3.A 4.B 5.C 6.C 7.A 8.C 9.D 10.B 编程 根据下面数学函数，编写程序根据x的值，计算y的值，后输出x和y的值。（使用多重if-else结构 完成) y = { -1(x <0) 0 (x=0) 1 (x>0) } x = -5; y = -1; public class IfElseDemo { public stat...
Java设计模式-图解-附代码.doc
最新发布
09-19
本文件“Java设计模式-图解-附代码.doc”主要探讨了Java语言中的设计模式，分为创建型、结构型和行为型三大类。下面将对这些模式进行详细解释。 1. **创建型模式**： - **工厂方法**：提供一个接口用于创建对象，...
计算机后端-Java-图解java设计模式代码.zip
05-23
在这个"计算机后端-Java-图解java设计模式代码.zip"压缩包中，我们很可能会找到各种Java设计模式的实例代码，这对于学习和理解设计模式非常有帮助。 首先，让我们来详细了解一下Java设计模式的一些主要类别： 1. *...
Java基础技术栈图解大全-xmind源文件
01-04
1. **Java编程语法**：Java语言以其严谨的语法著称，包括变量声明、常量定义、运算符、控制流（如if语句、for循环、while循环）以及方法定义等。理解这些基础知识是编写任何Java程序的前提。 2. **面向对象编程...
计算机后端-Java-图解java设计模式笔记.zip
05-23
本压缩包"计算机后端-Java-图解java设计模式笔记"提供了对Java设计模式的深入理解，通过图形化的方式帮助开发者更好地理解和应用这些模式。 1. **单例模式**：保证一个类只有一个实例，并提供一个全局访问点。常见...
计算机后端-Java-图解java设计模式001 设计模式面.mp4
05-23
计算机后端-Java-图解java设计模式001 设计模式面.mp4
流程控制50题
04-27
这些流程控制题目会锻炼你的开发思维能力,会使你以后工作中得到很大的提高.一起跟着我来解决这50道题吧~
JAVA基础知识： 流程控制习题答案
子木清风阁
03-23 3844
第一题： 有 36 人 36 块板砖，男人每人般 4 块，女人每人搬 3 块，小孩每 2 人搬 1 块。36 人都搬了一次，把砖刚好搬晚，问：几男几女的几个小孩？ int nan; int nv; for (nan = 1; nan 9; nan++) { for (nv = 1; nv 11; nv++) {
java 流程控制语句练习
邢家鹏(PHP)
03-01 736
题目： 判断一个数（小于10位）的位数。 例如：输入999，则输出 “它是个3位的数！” 渣代码： public class HelloWorld{ public static void main(String[] args){ int num = 999; int count = 0; int upNum...
java流程控制——30题练习（21-25题）
MoerPerfect的博客
05-26 133
心形输出（示爱小技巧）。100-200之间的质数。完数。4位数的吸血鬼数字。水仙花数。
Java(四)
二锅头的博客
07-07 890
作业题 /* 1. 定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现 */ class HomeWork01{ public static void main(String[] args){ //用三元运算符实现： int num1 = 10; int num2 = 20; int num3 = 25; int max = (num1 > num2)? num1 : num2; int max1 = (max > num3)
【JAVA基础速过】第2章 Java 基本语法（中）运算符
学无止境,勤则可达；志存高远,恒亦能成！
05-08 489
文章目录2 .4 运算符2.4.1 运算符：算术运算符1.算术运算符一览2.练习代码3.算术运算符的注意问题4.练习 1 ：算术运算符：自加、自减2.4.2 运算符： 赋值 运算符1.定义2.代码实操3.思考题2.4.3 运算符： 比较 运算符1.定义2.代码实操3.思考题2.4.4 运算符：逻辑运算符1.定义2.代码练习3.练习：请 写出每题的输出结果4.【 面试题 】 程序输出：2.4.5 运算符：位运算符1.定义2.代码实操3.位运算符的细节2.4.6 运算符：三元运算符1.定义2.代码演示2.4.7
Java流程控制练习题
zjy1102的博客
04-23 1955
一、选择题： 请看下面的程序代码，运行结果为：D A.2 B.3 C.4 D .编译出错，无结果 2.当a=1,b=3,c=5,d=4时，执行完下面一段程序后x的值是（B） if(a<b){ if(c<d){ x=1; }else{ if (a<c){ if (b<d){ x=2; } else{ x=3; } } else { x=6; } } }else {...
Practice03
Suntrumpl的博客
02-25 406
Practice 03 3.定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现 4.编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。 5.交换两个变量值的代码的实现 3.定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现 int num1 = 10,num2 = 21,num3 = -21; int max; if(num1 >= num2 &a
图解Java设计模式-23种设计模式
08-28
Java设计模式是一组经过实践验证的面向对象设计原则和模式，可以帮助开发人员解决常见的软件设计问题。下面是常见的23种设计模式： 1. 创建型模式（Creational Patterns）： - 工厂方法模式（Factory Method ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

寒 暄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值