循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。
1.心里存在一个数，这个数用来控制循环是否继续执行，以及循环次数
程序中需要存在一个变量 int i=1；
2.使用该变量进行条件判断，是否需要继续循环
i<=3; 1<=3; true;
3.循环任务开始
折返跑
4.循环任务结束一次后，变量自增
i++；
5.继续使用变量进行条件判断，是否要继续循环
i<=3; 2<=3; true
.....
for循环格式：
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
public static void main(String[] args){
for(int i = 1; i <= 3; i++){
System.out.println("折返跑");
}
}
需求：在控制台输出1-5和5-1的数据
示例代码：
public class Demo2For {
/*
需求：在控制台输出1-5和5-1的数据
分析:
1. 从1开始到5结束，设置初始化从1开始
2. 设置判断条件为没有到5的时候继续执行，执行到超过5程序结束
3. 从1到5，每次增加1，设置条件控制每次+1
4. 将反复进行的事情写入循环结构内部，打印对应数据
注意:
1. 循环中, 控制循环的变量, 可以作为逻辑组织到循环体中进行使用的.
2. 循环的 条件控制语句, 不要局限的认为只能是++
*/
public static void main(String[] args) {
// 1. 从1开始到5结束，设置初始化从1开始
// 2. 设置判断条件为没有到5的时候继续执行，执行到超过5程序结束
// 3. 从1到5，每次增加1，设置条件控制每次+1
for(int i = 1; i <= 5; i++){
// 4. 将反复进行的事情写入循环结构内部，打印对应数据
System.out.println(i); // 1 2 3
}
System.out.println("--------------");
for(int i = 5; i >= 1; i--){
System.out.println(i); // 5 4 3..
}
}
}
需求：求1-5之间的数据和，并把求和结果在控制台输出
示例代码：
public class Demo3For {
/*
需求：求1-5之间的数据和，并把求和结果在控制台输出
分析:
1. 求和的最终结果必须保存起来，需要定义一个变量，
用于保存求和的结果，初始值为0
2. 在循环中初始化一个变量从1开始，不断++，增长到5
3. 循环的过程中，将能够代表(1-5)的i变量和sum进行累加
4. 当循环执行完毕时，将最终数据打印出来
注意:
如果在今后的需求中, 看到了xxxx求和的字样, 就要定义一个求和变量
int sum = 0;
*/
public static void main(String[] args) {
// 1. 求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
int sum = 0;
// 2. 在循环中初始化一个变量从1开始，不断++，增长到5
for(int i = 1; i <= 5; i++){
// 3. 循环的过程中，将能够代表(1-5)的i变量和sum进行累加
//sum = sum + i;
sum += i;
}
// 4. 当循环执行完毕时，将最终数据打印出来
System.out.println("数据1-5的和为:" + sum);
}
}
今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
* 需求：求1-100之间的偶数和，并把求和结果在控制台输出 }
* 示例代码：
public class Demo4For {
/*
需求：求1-100之间的偶数和，并把求和结果在控制台输出
分析:
1. 需求是要求和, 定义求和变量.
2. 循环中获取1-100之间的每一个数值
3. 循环的过程中，对每一个数值进行if判断, 判断是否是偶数
4. 是偶数的话, 跟求和变量累加
5. 循环结束后, 打印最终结果
*/
public static void main(String[] args) {
// 1. 需求是要求和, 定义求和变量.
int sum = 0;
// 2. 循环中获取1-100之间的每一个数值
for(int i = 1; i <= 100; i++){
// 3. 循环的过程中，对每一个数值进行if判断, 判断是否是偶数
if(i % 2 == 0){
// 4. 是偶数的话, 跟求和变量累加
sum += i;
}
}
// 5. 循环结束后, 打印最终结果
System.out.println("1-100之间的偶数和为:" + sum);
}
}
需求：在控制台输出所有的“水仙花数”
解释：什么是水仙花数？
水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
例如153 3*3*3 + 5*5*5 + 1*1*1 = 153
思路：
获取所有的三位数，准备进行筛选，最小的三位数为100，最大的三位数为999，使用for循环获取
获取每一个三位数的个位，十位，百位，做if语句判断是否是水仙花数
示例代码
public class Demo5For {
/*
需求：在控制台输出所有的 “水仙花数”
水仙花数是一个三位数
水仙花数的个位、十位、百位的数字立方和等于原数
分析:
1. 通过循环获取所有的三位数100-999
2. 将每一个三位数拆分为个位, 十位, 百位
3. 加入if判断条件, 计算是否是水仙花数, 是的话输出打印.
*/
public static void main(String[] args) {
// 1. 通过循环获取所有的三位数100-999
for(int i = 100; i <= 999; i++){
// 2. 将每一个三位数拆分为个位, 十位, 百位
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
// int bai = i / 100;
// 3. 加入if判断条件, 计算是否是水仙花数, 是的话输出打印.
if( (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
System.out.println(i);
}
}
}
}
需求：在控制台输出所有的“水仙花数”，要求每行打印2个
示例代码：
public class Demo6For {
/*
需求：在控制台输出所有的“水仙花数”，要求每行打印2个
System.out.print (打印内容); 打印后不换行
System.out.println(打印内容); 打印后换行
分析:
1. 定义变量count，用于保存“打印过”的数量，初始值为0
2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，
并在打印后让count变量+1，记录打印过的数量
3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行。
*/
public static void main(String[] args){
// 1. 定义变量count，用于保存“打印过”的数量，初始值为0
int count = 0;
for(int i = 100; i <= 999; i++){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if( (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
// 2. 在判定和打印水仙花数的过程中，拼接空格,
//但不换行，并在打印后让count变量+1，记录打印过的数量
System.out.print(i + " ");
count++;
// 3. 在每一次count变量+1后，判断是否到达了2的倍数，
//是的话，换行
if(count % 2 == 0){
System.out.println();
}
}
}
}
}
今后如果需求带有统计xxx，请先想到计数器变量
* while循环完整格式：
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
需求: 在控制台打印1-100之间所有的数
需求: 在控制台打印520次 I LOVE YOU
public static void main(String[] args) {
/*
for(int i = 1; i <= 100; i++){
System.out.println(i);
}
*/
int i = 1;
while(i <= 520){
System.out.println("I LOVE YOU");
i++;
}
}
执行流程：
* 需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
* 示例代码：
public class Demo2While {
/*
步骤:
1. 定义计数器变量, 准备用于统计折叠的次数
2. 准备纸张厚度变量, 珠峰高度变量
3. 折叠的过程是多次, 所以使用循环, 不确定循环次数, 使用while循环
进入循环的条件为(厚度没有超过珠峰的高度就折叠)
4. 每折叠一次, 计数器就要自增(查数)
5. 循环结束后, 打印计数器变量即可.
*/
public static void main(String[] args){
// 1. 定义计数器变量, 准备用于统计折叠的次数
int count = 0;
// 2. 准备纸张厚度变量, 珠峰高度变量
double paper = 0.1;
int zf = 8844430;
//3. 折叠的过程是多次, 所以使用循环, 不确定循环次数, 使用while循环
// 进入循环的条件为(厚度没有超过珠峰的高度就折叠)
while(paper <= zf){
paper *= 2;
System.out.println(paper);
// 4. 每折叠一次, 计数器就要自增(查数)
count++;
}
// 5. 循环结束后, 打印计数器变量即可.
System.out.println(count);
}
}
完整格式：
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句);
① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
// 需求: 在控制台打印10次黑马程序员
public class Demo1DoWhile {
/*
特点:
do..while循环, 无论循环条件是否满足, 都至少会执行一次循环体.
原因: do..while循环是从上到下依次执行.
*/
public static void main(String[] args){
int i = 11;
do {
System.out.println("黑马程序员");
i++;
}while(i <= 10);
System.out.println(i);
}
}
流程图
三种循环的区别
for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
for循环和while的区别
条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
public class Loop {
/*
for和while的区别：
条件控制语句所控制的自增变量
因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
条件控制语句所控制的自增变量
对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
*/
public static void main(String[] args){
for(int i = 1; i <= 5; i++){
// for循环内部[定义]的变量, 在循环结束后, 就会从内存中消失
System.out.println(i);
}
// System.out.println(i); // 错误: 找不到符号i
System.out.println("--------------");
for(int i = 1; i <= 10; i++){
System.out.println(i);
}
System.out.println("--------------");
// while循环
int a = 1;
while(a <= 5){
System.out.println(a);
a++;
}
System.out.println(a + "...");
}
}
do...while循环，很少使用
死循环格式
举例一：不开心我就吃，吃了我就胖，胖了我就不开心
举例二：第一天上课没精神，晚上熬夜复习，第二天上课没精神，晚上熬夜复习，第三天......
/*
问题: 死循环有应用场景吗?
例如: 键盘录入一个1-100之间的整数
顾虑: 键盘录入是用户操作的, 用户就可能会出现一些误操作的现象
*/
public static void main(String[] args) {
/*
for(;;){
System.out.println("我停不下来了~");
}
*/
/*
while(true){
System.out.println("我停不下来了~");
}
*/
do{
System.out.println("我停不下来了~");
}while(true);
System.out.println("看看我能被执行吗?~"); // 无法访问的语句
}
}
while的死循环格式是最常用的
命令提示符窗口Ctrl+C可以结束死循环
跳转控制语句（break）
跳出循环，结束循环
跳转控制语句（continue）
跳过本次循环，继续下次循环
注意： continue只能在循环中进行使用！
需求: 模拟电梯上行的过程 1-24层, 4层不停.
public class Demo1Continue {
/*
continue : 跳过某次循环体内容的执行
注意：使用是基于条件控制, 在循环内部使用.
*/
public static void main(String[] args){
for(int i = 1; i <= 24; i++){
if(i == 4){
continue;
}
System.out.println(i + "层到了~");
}
}
}
需求: 模拟20岁工作到80岁, 60岁退休.
public class Demo2Break {
/*
break : 终止循环体内容的执行
注意：使用是基于条件控制的
break语句只能在循环和switch中进行使用.
*/
public static void main(String[] args){
for(int i = 20; i <= 80; i++){
if(i == 60){
break; // 结束整个循环
}
System.out.println(i + "岁正在上班");
}
}
}
跳转控制语句小结
continue 用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
break 用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
案例：减肥计划改进
需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束
import java.util.Scanner;
public class Test {
/*
需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束
步骤:
1. 不明确用户操作几次, 使用死循环包裹业务逻辑
2. 匹配到0的时候，使用break结束循环死循环
*/
public static void main (String[] args){
lo:while(true){ //命名 lo！！！！ 标号
System.out.println("请输入您要查看的星期数:");
System.out.println("(如无需继续查看,请输入0退出程序)");
// 1. 键盘录入星期数据，使用变量接收
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
// 2. 多情况判断，采用switch语句实现
switch(week){
// 3. 在不同的case中，输出对应的减肥计划
case 0:
System.out.println("感谢您的使用");
break lo;
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
default:
System.out.println("您的输入有误");
break;
}
}
}
}
小结：break和continue只能跳出，跳过自己所在的那一层关系，如果想要跳出，跳过指定的一层，就可以加入标号！！！！
概述：
Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
API后续课程详细讲解，现在可以简单理解为Java已经写好的代码
使用步骤：
导入包
import java.util.Random; 导包的动作必须出现在类定义的上面
Random r = new Random();
产生随机数
int num = r.nextInt(10);
解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19
import java.util.Random;
public class Demo1Random {
/*
Random : 产生随机数
1. 导包 : import java.util.Random;
导包的动作必须出现在类定义的上面
2. 创建对象 : Random r = new Random();
上面这个格式里面，r 是变量名，可以变，其他的都不允许变
3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围：[0,10) 包括0,不包括10
上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不允许变
需求: 产生随机数1-10之间的
*/
public static void main(String[] args){
// 2. 创建对象
Random r = new Random();
for(int i = 1; i <= 10; i++){
// 3. 获取随机数
int num = r.nextInt(10) + 1; // 1-10
System.out.println(num);
}
}
}
案例：猜数字
程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
当猜错的时候根据不同情况给出相应的提示
A. 如果猜的数字比真实数字大，提示你猜的数据大了
B. 如果猜的数字比真实数字小，提示你猜的数据小了
示例代码：
import java.util.Scanner;
import java.util.Random;
public class Test {
/*
1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
2. 使用Random产生一个1-100之间的数, 作为要猜的数
3. 键盘录入用户猜的的数据
4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
6. 猜对之后, break结束.
*/
public static void main(String[] args){
// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
Random r = new Random();
Scanner sc = new Scanner(System.in);
// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
int randomNum = r.nextInt(100) + 1;
// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
while(true){
// 3. 键盘录入用户猜的的数据
System.out.println("请输入您猜的数据:");
int num = sc.nextInt();
// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
if(num > randomNum){
System.out.println("猜大了");
}else if(num < randomNum){
System.out.println("猜小了");
}else{
// 6. 猜对之后, break结束.
System.out.println("恭喜,猜中了");
break;
}
}
System.out.println("感谢您的使用");
}
}
原文：https://www.cnblogs.com/faded8679/p/13848444.html