循环结构
介绍循环语句的应用场景，学会用“循环”思想解决实际问题；介绍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。标签：语句,int,System,while,循环,结构,out From： https://www.cnblogs.com/0216-zkr/p/17800550.html