526互联

循环结构

发布时间 2023-12-04 16:59:04作者: 仧空

循环结构

　　介绍循环语句的应用场景，学会用“循环”思想解决实际问题；介绍java中的三种循环语句，掌握循环语句的结构，学会for语句、while语句及do-while的使用，掌握各循环语句的区别及实际开发中的取舍，理解嵌套循环的应用场景，掌握嵌套循环的使用，掌握break、continue、return语句在循环语句中的使用。

for循环

示例：

package Java04;
/**
 * 计算0-100自然数和
 * @author ThinkPad
 *
 */
public class ContinueDemo {
    public static void main(String[] args) {
        int sum = 0;
        int i;
        for(i = 0;i <= 100;i++) {
            if(i % 10 ==0) {
                continue;//结束本次循环，判断下次循环条件，继续下一次循环
            }
            sum += i;
        }
        System.out.println("sum = " + sum);
    }
}

运行过程：

　　for循环语句是基础循环语句之一。将for循环分成四个部分：

　　for(①;②;③){④}

　　在上面所示代码当中，①表示定义一个初始值，②表示循环条件(若不满足循环条件跳出循环)，③循环叠加初始值，④循环语句。其中执行顺序为①、②、④、③、①......

嵌套for循环进行进阶版for循环

 

package Java04;
/**
 * 嵌套循环99乘法表
 * @author ThinkPad
 *
 */
public class MultiLoop {
    public static void main(String[] args) {
        for(int i =1;i <= 9;i++) {
            for(int j =1;j <= i;j++) {
                System.out.printf("%d * %d = %2d  ",j,i,i*j);
            }
            System.out.println("");
        }
    }
}

 

　　以上运行结果为:

 　　我们同样进行分析。

　　for(①;②;③){

　　　　for(④;⑤;⑥){

　　　　　　⑦

　　　　}

　　}

　　在上面所示代码中执行顺序是(假设内层for循环两次):①、②、④、⑤、⑦、⑥、④、⑤、⑦、⑥、③、④......

鸡兔同笼问题

package Work1029;
/**
 * 需求：
 *  百元百鸡问题：公鸡5元一只，母鸡3元一只，3只小鸡1元，如果用100元钱，买100只鸡，不佘不欠，可以买公鸡，母鸡，小鸡，各多少只。
 * 1.利用for循环，假设不买公鸡，母鸡买到最多，剩下的买小鸡，使最后母鸡加小鸡和为100只，
 * 以此类推，算买一只公鸡后剩下的钱全买母鸡和小鸡，能否买到100只，不能则继续循环，能则打印出来
 * 2.判断条件：i + j + k == 100 && (5 * i + 3 * j + k / 3 == 100
 *
 */
public class Homework5_1029 {
    public static void main(String[] args) {
        int i,j,k;
        for (i = 0; i < 100; i++) {
            for (j = 0; j < 100; j++) {
                for (k = 0; k < 100; k++) {
                    if (i + j + k == 100 && (5 * i + 3 * j + k / 3 == 100) && k % 3 == 0) {
                        System.out.println("公鸡有：" + i + "只" + ",母鸡有：" + j + "只" + ",小鸡有：" + k + "只");
                    }
                }
            }
        }
    }
}

买鸡问题

package Work1029;
/**
 * 需求：
 *  百元百鸡问题：公鸡5元一只，母鸡3元一只，3只小鸡1元，如果用100元钱，买100只鸡，不佘不欠，可以买公鸡，母鸡，小鸡，各多少只。
 * 1.利用for循环，假设不买公鸡，母鸡买到最多，剩下的买小鸡，使最后母鸡加小鸡和为100只，
 * 以此类推，算买一只公鸡后剩下的钱全买母鸡和小鸡，能否买到100只，不能则继续循环，能则打印出来
 * 2.判断条件：i + j + k == 100 && (5 * i + 3 * j + k / 3 == 100
 *
 */
public class Homework5_1029 {
    public static void main(String[] args) {
        int i,j,k;
        for (i = 0; i < 100; i++) {
            for (j = 0; j < 100; j++) {
                for (k = 0; k < 100; k++) {
                    if (i + j + k == 100 && (5 * i + 3 * j + k / 3 == 100) && k % 3 == 0) {
                        System.out.println("公鸡有：" + i + "只" + ",母鸡有：" + j + "只" + ",小鸡有：" + k + "只");
                    }
                }
            }
        }
    }
}

打印如图所示（方框忽略）

1.

2.

3.

4.

5.

6.

package Work1029;
public class Homework19_1029 {
    public static void main(String[] args) {
        System.out.println("图1");
        for(int i = 1;i <= 6;i++) {
            for(int j = 1;j <= i;j++) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------");
        System.out.println("图2");
        for(int i = 6;i >= 1;i--) {
            for(int j = 1;j <= i;j++) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------");
        System.out.println("图3");
        for(int i = 1;i <= 6;i++) {
            for(int j = 5;j >= i;j--) {
                System.out.print("\t");
            }
            for(int j = i;j >= 1;j--) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------");
        System.out.println("图4");
        for(int i = 6;i >= 1;i--) {
            for(int j = 5;j >= i;j--) {
                System.out.print("\t");
            }
            for(int j = 1;j <= i;j++) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------");
        System.out.println("图5");
        for(int i = 1;i <= 6;i++) {
            for(int j = 5;j >= i;j--) {
                System.out.print("\t");
            }
            for(int j = i;j >= 1;j--) {
                System.out.print(j + "\t");
            }
            for(int j = 2;j<=i;j++) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------");
        System.out.println("图6");
        for(int i = 1;i <= 6;i++) {
            for(int j = 5;j >= i;j--) {
                System.out.print("\t");
            }
            for(int j = 0;j <= i - 1 ;j++) {
                System.out.print(Math.pow(2,j) + "\t");
            }
            for(int j = i - 2;j >= 0;j--) {
                System.out.print(Math.pow(2,j) + "\t");
            }
            System.out.println();
        }
    }
}

foreach与for循环的区别：

　　1、for与foreach都可以遍历数组/集合，不过for则在较复杂的循环中效率更高。
　　2、foreach不可以删除/修改集合元素，而for可以
　　3、foreach和for都可以修改元素里面的属性

　　foreach语句：

　　　　for(数据类型 自定义变量 : 需要遍历的集合或数组等)

 String[] array = {"1", "2", "3"};
 for (String i : array) {
 　　System.out.println(i);
 }
 ArrayList<String> list = new ArrayList<>();
 list.add("111");
 list.add("222");
 list.add("333");
 for (String i : list) {
    System.out.println(i);
 }

　　在面向对象类里使用foreach

//-------------------------学生类----------------------------
public class Student {
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    private String name;
    public Student(){};
    public Student(int age,String name){
        this.age=age;
        this.name=name;
    }
} 
//-------------------------测试类----------------------------
    Student student=new Student(1,"huge");
    Student student1=new Student(1,"xiaoyao");
    List<Student> studentList=new ArrayList<Student>();
    studentList.add(student);
    studentList.add(student1);
    System.out.println(student.getName());
    System.out.println(student1.getName());
    for(Student stu:studentList)
    {
        stu.setName("jingtian");
    }
    System.out.println(student.getName());
    System.out.println(student1.getName());

while循环

示例：

package Java04;
/**
 * while循环案例猜数字游戏
 */
import java.util.Random;
import java.util.Scanner;

public class Guessnumber {
    public static void main(String[] args) {
        Random random = new Random();
        //生成100以内不包含100
        int num = random.nextInt(100);
        System.out.println("请猜测100以内的数字：");
        Scanner input = new Scanner(System.in);
        int guess = 0;
        while(guess != num) {
            guess = input.nextInt();
            if(guess > num) {
                System.out.println("猜大了");
            }
            else if(guess < num){
                System.out.println("猜小了");
            }
            else {
                System.out.println("猜对了，该数字为：" + num);
            }
        }
        input.close();
    }
}
package Java04;
/**
 * while案例循环多个减法计算题
 */
import java.util.Random;
import java.util.Scanner;
public class SubstractionQuizLoop {
    public static void main(String[] args) {
        final int NUMBER_QUESTION = 5;
        int count = 0;//做题的总数,初始化部分
        int correctcount = 0;//正确题的数量
        Scanner input = new Scanner(System.in);
        Random random = new Random();
        //确定循环语句
        while(count < NUMBER_QUESTION) {
            int num1 = random.nextInt(10);
            int num2 = random.nextInt(10);
            if(num2 > num1) {
                int tmp = num1;
                num1 = num2;
                num2 = tmp;
            }
            System.out.printf("%d - %d = ",num1,num2);
            int answer = input.nextInt();
            if(answer == (num1 - num2)) {
                System.out.println("回答正确");
                correctcount++;
            }
            else {
                System.out.println("回答错误");
            }
            count++;
        }
        System.out.println("====================");
        System.out.println("本次练习你做对了：" + correctcount + " 道题");
        System.out.println("本次练习你做错了：" + (NUMBER_QUESTION-correctcount) + " 道题");
        input.close();
    }
}
package Java04;
/**
 * while案例计算输入数字的求和并使用标记值控制循环
 */
import java.util.Scanner;

public class SentineValue {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入你要计算求和的数，0退出");
        //初始化部分
        int num = input.nextInt();
        int sum = 0;
        while(num !=0) {//标记部分，当输入的数字为0时退出程序
            sum += num;
            System.out.println("请输入你要计算求和的数，0退出");
            num = input.nextInt();
        }
        System.out.println("sum = " + sum);
        input.close();
    }
}

　　while循环结构为：

　　while(条件语句①){②}

　　当条件语句为true时，执行循环语句，条件语句为false时退出循环。执行顺序为①、②、①.......

while与for相互嵌套案例:

while循环嵌套for循环：

package Java04;
/**
 * 显示前50个素数，每行显示10个
 * 素数：大于1的整数，只能被1和它自身整除的数即是素数
 * 1.判断给定的一个数十不是素数
 * 2.number=2，3，4，5，，，，
 * 3.统计素数个数
 * 4.打印
 * 
 * 测试一个数是不是一个素数：
 *     检测这个数能否被2，3，4一直到number/2整除，如果能被任意一个整除，就不是素数，break
 *
 */
public class Primenumber {
    public static void main(String[] args) {
        //素数总数
        final int NUMBER_OF_PRIMES = 50;
        //每行显示素数个数
        final int NUMBER_OF_LINES = 10;
        int count = 0;
        int num = 2;
        while(count < NUMBER_OF_PRIMES) {
            boolean isprime = true;
            for(int i =2;i <= num / 2;i++) {
                if(num % i == 0) {
                    isprime = false;
                    break;
                }
            }
            if(isprime) {
                count++;
                System.out.printf("%3d  %s",num,count % NUMBER_OF_LINES == 0 ? "\r\n" : " ");
            }
            num ++;
        }
    }
}

for循环嵌套while循环：

boll find=false; //定义一个布尔型的变量，初始值为false
for(int i=1;i<num;i++){
    while(b[0]!=a[i]){
        b[1]=a[i];
        count++;
        break;
        find = true;//while中做一个标记，break前，设置为true
    }
    //while外，for语句内加一句判断这个变量的代码
    if (find) {
        break;
    }
}

　　举个例子，在for语句里加入了while循环，如果while的条件满足，则执行下面的语句，然后跳出这个循环，然后执行下一个语句。

do-while循环

示例：

package Java04;
/**
 * do..while循环
 */
import java.util.Scanner;
public class Dowhiledemo {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int num = 0;
        int sum = 0;
        do {
            System.out.println("请输入你要计算的数的和，0退出");
            num = input.nextInt();
            sum += num;
        }while(num != 0);
        input.close();
        System.out.println("sum = " + sum);
    }
}

　　do-while循环结构

　　do{

　　①

　　}while（②）

　　①为循环语句，②为条件语句，do-while循环与while循环的区别在于do-while循环会且必定会执行一次循环语句，在进行条件语句判断，若条件语句为true，则再次执行循环语句进入循环，若为false，则跳出循环。执行顺序为：①、②、①、②、①......

注：在使用嵌套循环时最好不要超过两个，不然会大大降低代码的可读性和程序性能

break、continue、return的使用

　　break语句的使用场合主要是switch语句和循环结构。在循环结构中使用break语句，如果执行了break语句，那么就退出循环，接着执行循环结构下面的第一条语句。如果在多重嵌套循环中使用break语句，当执行break语句的时候，退出的是它所在的循环结构，对外层循环没有任何影响。如果循环结构里有switch语句，并且在switch语句中使用了break语句，当执行switch语句中的break语句时，仅退出switch语句，不会退出外面的循环结构。

　　continue语句是这5种结束循环的方式中最特殊的，因为它并没有真的退出循环，而是只结束本次循环体的执行，所以在使用continue的时候要注意这一点。下图所示为各种循环结构中continue语句的使用。

　　在for循环中，首先执行表达式1（注意表达式1在整个循环中仅执行一次），接着执行表达式2，如果满足条件，那么执行循环体，如果在循环体中执行了continue语句，那么就跳转到表达式3处执行，接下进行下一次循环，执行表达式2，看是否满足条件；在while循环中，如果执行了continue语句，那么就直接跳转到表达式处，开始下一次的循环判断；在do while循环体中如果执行了continue语句，那么就跳转到表达式处进行下一次的循环判断，这一点前面已经验证过了。

　　如果在程序中遇到return语句，那么代码就退出该函数的执行，返回到函数的调用处，如果是main()函数，那么结束整个程序的运行。如果是在自定义的函数中执行，那么执行return之后就返回到函数的调用处继续往下执行。

 三种循环的区别

　　for循环,知道循环次数使用for，不知道使用while，若无论循环是否执行都需要执行一次语句采用do..while。