文章目录
Java 循环语句
理解：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能
循环结构分类：
- for 循环
- while 循环
- do - while 循环
循环结构四要素： - 初始化部分
- 循环条件部分
- 循环体部分
- 迭代部分
一，for 循环
1. for 循环结构
循环测试
1). Java 中规范了3种循环结构：for, while , do-while
2). 凡是循环结构，就一定会有4个要素:
① 初始化条件
② 循环条件 --> 一定是 boolen 类型的变量 或者表达式
③ 循环体
④ 迭代部分
3). for 循环的格式
for(①;②;④){
③
}
执行过程: ① - ② - ③ - ④ - ② - ③ - ④ … ② - ③ - ④ 初始化部分只走一次，后面都是不重复的
说明：
- 我们可以在循环结构中使用break。一旦执行break，就跳出（或结束）当前循环结构。
- 如何结束一个循环结构?
方式1：循环条件不满足。（即循环条件执行完以后是false）
方式2：在循环体中执行了break
2. for 循环案例: 输出5行HelloWord
- 设置初始化变量
- 设置循环条件
- 输出循环体内容
- 设置迭代部分
然后重复 2,3,4部分 直到不满足 循环条件 跳出for 循环
for(int i=1;i<=5;i++){
System.out.println("HelloWord");
}
输出结果:
3. for 循环案例: 写出输出的结果 (格式多样性)
这个主要是查看 for 循环格式的多样性，来看for 循环的流程
先是初始化部分，输出了一个a,然后到第二部分循环条件，num 值为1,小于3然后到循环体部分，输出b,然后到迭代部分先输出一个c，然后num + 1 现在num变成2了，再进去循环体输出b，然后再到迭代部分，输出一个c，num + 1，现在 num 变成3了，不满足循环条件，跳出 for 循环。所以输出的结果是
a,b,c,b,c
int num = 1;
for(System.out.print("a");num < 3;System.out.print("c"),num++){
System.out.print("b");
}
输出结果
4. for 循环案例: 遍历100以内的偶数。并获取偶数的个数，获取所有的偶数的和
这个主要是看 for 循环的累加思想
我们先看 for 循环体内，首先是要遍历出 100 以内的偶数，因为是要偶数，而且知道范围是在 100 以内，那我们初始值直接设置为2，然后循环条件设置为小于等于 100，然后i += 2，因为是要偶数，我们的初始值是2，然后每次加2那么每次都是偶数了，然后把 i 输出出来就行了，每次都是输出的偶数，然后我们开始解决第二个问题，记录个数和偶数的和，我们得定义两个变量来接，一个 count 变量，一个 sums 变量，每次 count + 1就可以了，输出偶数的时候，每输出一次，count 就 + 1了，当for 循环结束的时候，循环了多少次，count 就记录了多少次也就是偶数的个数了，sums 就是每次输出的偶数的值加起来就行，sums += i , i 就是输出的每次的偶数的值，循环了50次每次都把之前的和给加起来。
int count = 0; //这个是 记录偶数的个数
int sums = 0; // 这个是记录偶数的和
for(int i=2;i<=100;i+=2){
System.out.print(i);
count += 1;
sums += i;
}
System.out.println("偶数个数:" + count + "偶数的和:" + sums);
结果输出： 这里太长了 我们就不全部截了，最后结果 100 以内偶数 50 个，100以内偶数的和 2550
5. for 循环案例: 输出所有的水仙花数
所谓水仙花数是指一个3位数，其各各位上数字立方和等于其本身
例如：153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3
我们结合分支结构使用
解题思路：首先水仙花数 是三位数，所以设置 循环初始值为 100 ，然后循环条件 i < 1000，然后我们得想办法把这个三位数的每一位数给取出来，百位 直接除以一个 100 就能得到 百位上的数，比如 300 / 100 = 3，然后十位 先除以一个 10 再取余 10 ，比如 310 / 10 % 10 = 1 我们先除以10等于31，然后31对10取余结果就是1，然后我们取各位上的数，直接对10取余，比如 31 % 10 结果就为 1，这样我们各个位置上的数都取到了，接下来 if 判断，如果这三个 位 的各自的立方，加起来的总数等于这个数，那么就是水仙花数，例如 153 = 1 * 1 *1 + 5 * 5 * 5 + 3 * 3 * 3
for(int i=100;i<1000;i++){
// 针对每一个 三位数i ,获取其各个位数上面的值
int baiwei = i / 100 ; //获得百位上的数
int shiwei = i / 10 % 10; // 获取十位上的数
int gewei = i % 10; // 获取个位上的数
// 判断是否满足水仙花数的规则
if((baiwei * baiwei * baiwei) + (shiwei * shiwei * shiwei) + (gewei * gewei * gewei)==i){
System.out.println(i);
}
}
输出结果
6. for 循环案例: 输入两个正整数 m 和 n，求其最大公约数和最小公倍数
比如 12 和 24 的 最大公约数是 4，最小公倍数 是 60
约数：12 为例，约数有 1,2,3,4,6,12
20 为例：约数有1,2,4,5,10.20
思路我们先求最大公约数:
我们这里需要定义两个数，然后 for 循环开始，我们这里 初始值是从1开始，因为他们的公约数都是从1开始的，然后，循环条件设置为小于等于这两个数里面较小的那一个，然后 i++ ，下面是循环体内，我们判断一下，如果这两个数 分别除以那个数都能够整数，说明这就是他们的公约数，然后这里的输出的结果是从小到大的，比如他们除以1的时候都能够整数，除以2的时候也能够被整除，那么我们定义一个空的列表，把这些公约数都放进列表里，然后对这个列表里的数进行排序，取最大的一个，这里我们是直接用的取最大值，Collections.max(num) 方法，数组里取最大值,最大公约数取完了
int n1 = 12;
int n2 =20;
//获取n1和n2中的较小值
int min = (n1 < n2)? n1:n2;
List<Integer> num = new ArrayList<Integer>(); //用来装他们的最大公约数
for(int i=1;i<=min;i++){
if(n1 % i == 0 && n2 % i == 0){
num.add(i);
}
}
Integer maxs = Collections.max(num); // 获取list 列表中的最大数
System.out.println("他们的最大公约数为:" + maxs); // 获取到 他们的最大公约数
接下来取最小公倍数：
倍数：12为例，倍数有12,24,36,48,60,72…
20为例，倍数有20,40,60,80…
也就是能够整数他们的数
思路：能够同时整数他们两个，说明至少也得是他们这两个数里最大的那个。获取n1和n2中的较大值，然后我们for 循环里的内容，首先初始值，设置为他们里最大的那个数，用了一个 max 变量去接，然后循环条件，i >= 1 因为他们的公倍数是无穷的，然后迭代 i++，然后我们循环里 if 判断，能够同时除以他们的数 那么就输出，因为我们要的是最小的公倍数，所以第一个公倍数出来的时候，我们就可以中止循环了，加上了一个break。
int max = (n1 > n2)? n1:n2;
for(int i=max;i>=1;i++){
if(i%n1 == 0 && i%n2==0){
System.out.println("他们的最小公倍数为："+i);
break;
}
}
结果输出;
7. for 循环案例: ATM取款
声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。
===========ATM===========
1.存款
2.取款
3.显示余额
4.退出
请选择(1-4):
实现思路：我们首先需求是要求有4个功能，第一个是能存款，第二个是能够取款，第三个是显示余额，第四个是退出程序，我们要去存款，肯定的从键盘输入数值，所以第一步的设置一个从键盘输入的数值的变量用来存钱的初始值，然后第二步我们进入循环里，首先是循环初始值，我们设置一个boolen类型的变量tuichu2来控制循环一直运行，然后循环条件就是这个变量本身，也就是为true的时候循环，然后上面的界面的内容我们得打印出来，然后用于要选择功能，所以我们要再设置一个从键盘输入的变量，来控制用户输入的选项，接下来就是 if 判断，用户输入什么数字对应进入什么功能，进入1是存款，是输入存款的金额，那我们设置个变量来存这个值，然后赋值给 balanceue, balanceue += money3; 因为他是我们设置的存钱的初始值，然后第二个是取款，我们同样的设置一个变量来接收取款的金额，然后 balanceue -= money4; 一样的逻辑，然后4就是退出了，这个时候我们让 循环条件 tuichu2 = false 跳出循环。
// for循环实现
Scanner scan = new Scanner(System.in);
double balanceue = scan.nextDouble(); //定义变量，来记录银行余额
for(boolean tuichu2 = true;tuichu2;){
System.out.println("===========ATM=========");
System.out.println("请选择1-4");
System.out.println("1.存款");
System.out.println("2.取款");
System.out.println("3.显示余额");
System.out.println("4.退出");
int xuanze2 = scan.nextInt(); //用来控制用户输入选项
if(xuanze2 == 1){
System.out.println("输入你的存款数:");
double money3 = scan.nextDouble();
balanceue += money3;
}else if(xuanze2 == 2) {
System.out.println("输入你的取款金额:");
double money4 = scan.nextDouble();
balanceue -= money4;
}else if(xuanze2 == 3) {
System.out.println("你的余额为：" + balanceue);
}else if(xuanze2 == 4){
System.out.println("退出程序");
tuichu2 = false;
}
}
结果输出:
二，while 循环
1. while 循环结构
- Java 中规范了3种循环结构：for, while , do-while
- 凡是循环结构，就一定会有4个要素:
① 初始化条件
② 循环条件 --> 一定是 boolen 类型的变量 或者表达式
③ 循环体
④ 迭代部分 - while 的格式
①
while(②)
③
④ - 执行过程：① - ② -③ - ④ - ② - ③ - ④ - … - ② (和for循环过程是一样的)
- for循环和while 循环可以相互转换
- for循环和while循环的小区别：初始化条件的作用域范围不同，while循环中的初始化条件在while循环结束后，依然有效
2. while 循环案例：遍历100以内的偶数。并获取偶数的个数，获取所有的偶数的和
我们将这个案例，用 while 循环再实现一下
思路：while 循环和 for循环的不同点，他的初始值是在 循环体外面，我们设置一个变量值为2，因为是求偶数，然后循环条件，num2 <= 100，因为是100以内的，然后是循环体，每次 num2 += 2，
这样知道不满足 num2<=100 的时候，跳出循环，我们把所有的偶数得到了，然后要记录个数，还有偶数的和，还是一样的设置两个变量来接，每循环一次，counts++，记录个数，然后sums += num2，进行累加，然后都得到了，我这里是把所有的偶数放在列表里去了，这样比较好看。
//需求2：遍历1-100以内的偶数，并获取偶数的个数，并且并获取偶数的个数，获取所有的偶数的和
int num2 = 2; //这是初始值
int count = 0; //定义一个变量记录个数
int sums = 0; //定义一个变量接收总和
ArrayList<Integer> arrayList = new ArrayList<Integer>();
while (num2 <= 100) {
sums += num2;
arrayList.add(num2);
num2 += 2;
count++;
}
System.out.println("100以内的偶数:" + arrayList);
System.out.println("100以内的偶数有:" + count + "个" + "总和为：" + sums);
3. while 循环案例：随机生成一个100以内的数，猜这个随机数是多少
规则：从键盘输入数，如果大了，提示大了，如果小了，提示小了，如果对了，就不在猜了，并统计一共猜了多少次。
提示：生成一个[a,b] 范围的随机数的方式：(int)(Math.ranom() * (b - a + 1) + a)
思路：首先我们用 Math.random()方法生成一个 随机数，这个方法生成的数是[0,1]的随机的double值，所以我们得乘上一个100，这样生成的就是0到100的随机数了，这个是一个double数，我们在前面加上(int)强制转换为 int 类型，然后我们从键盘输入一个0-100的数，然后我们开始写while循环，我们的初始值就是 键盘输入的值，然后循环条件是，这两个数不想当，当他们等于的时候，就跳出循环了，if 判断如果输入的数大于随机生成的数， 那么提升输入的数大了，如果输入的数小于随机生成的数，那么提示输入的数小了，然后我们在判断条件外，重新从键盘中输入一个数，然后再次判断，直到他们相等，跳出循环，我们也是定义一个变量counts，来记录猜的次数，每猜一次，counts++，这道题就完成了。
//1. 生成一个[1,100]范围内的随机整数
int target = (int)(Math.random() * 100) + 1; //在前面加上(int)是强转为 int 类型，获取一个大于等于0.0且小于1.0的伪随机double值所以乘上一个100
//2. 使用Scanner，从键盘获取数据
//3. 使用循环结构，进行多次循环的对比和获取数据
Scanner input= new Scanner(System.in); //从键盘获取数据
System.out.println("请输入0-100的整数:");
int shuchu = input.nextInt();
int counts = 1; // 记录猜了多少次
while (shuchu != target) {
if(shuchu > target){
System.out.println("输入的数大了");
}else if (shuchu < target) {
System.out.println("输入的数小了");
}
System.out.println("请输入0-100的整数:");
shuchu = input.nextInt();
counts++;
}
System.out.println("恭喜你，猜对了");
System.out.println("猜了" + counts + "次" );
结果输出：
4. while 循环案例: 折纸珠穆朗玛峰
世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米，请问我折叠多少次，可以折叠成珠穆朗玛峰的高度?
1 米 等于 1000 毫米，8848.86米 = 8848860 毫米
思路：就是每次 * 2 就行了，循环，直到大于等于 8848.86 跳出循环 ,这是指数级的增长，0.1的初始值，折叠27次就到珠峰高度了。
double paper = 0.1; //单位：毫米
int countss = 0; // 记录折的次数
while (paper <= 8848860) {
paper *= 2;
countss++;
}
System.out.println("折叠了" + countss + "次" + "到达了珠峰的高度");
结果输出;
5. while 循环案例: ATM取款
声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。
===========ATM===========
1.存款
2.取款
3.显示余额
4.退出
请选择(1-4):
//定义balance变量，用来记录银行余额
double balance = 0;
Scanner input = new Scanner(System.in);
boolean tuichu = true; //用来控制退出
// //生成ATM取款的界面（这部分会反复出现，放在循环里）
while (tuichu) {
System.out.println("===========ATM=========");
System.out.println("请选择1-4");
System.out.println("1.存款");
System.out.println("2.取款");
System.out.println("3.显示余额");
System.out.println("4.退出");
int xuanze = input.nextInt();
if(xuanze == 1){
System.out.println("请输入存款的余额");
double money1 = input.nextDouble();
if(money1 > 0){
balance += money1;
}
}else if(xuanze == 2){
System.out.println("请输入取款金额");
double money2 = input.nextDouble();
balance -= money2;
}else if(xuanze == 3){
System.err.println("余额为：" + balance);
}else if (xuanze == 4) {
System.out.println("退出程序");
tuichu = false;
}else{
System.out.println("输入有误,重新输入");
}
}
三，do-while 循环
1. do-while 循环结构
循环测试 - do-while
-
Java 中规范了3种循环结构：for, while , do-while
-
凡是循环结构，就一定会有4个要素:
① 初始化条件
② 循环条件 --> 一定是 boolen 类型的变量 或者表达式
③ 循环体
④ 迭代部分 -
do-while 的格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分) -
执行过程：① - ③ -④ - ② - ③ -④ - ② - ③ - ④ … - ②
5.说明：
do-while 循环至少会执行一次循环体
for循环，while循环，do-while循环,三者之间是可以相互转换的
do-while循环结构，在开发中，相较于for,while循环来讲，使用的比较少
2. do-while 循环案例:遍历100以内的偶数，并且输出偶数的个数和总和
//遍历100以内的偶数，并且输出偶数的个数和总和
int num = 2;
int count = 0; //记录偶数个数
int sum = 0;//记录偶数总和
do{
System.out.println(num);
num += 2;
count++;
sum += num;
}while(num <= 100);
System.out.println("偶数个数有：" + count + "个" + "偶数总和为" + sum);
3. do-while 循环案例: ATM取款
//do-while 实现
Scanner scan = new Scanner(System.in);
boolean tuichu = true;
double qian = scan.nextDouble();
do{
System.out.println("===========ATM=========");
System.out.println("请选择1-4");
System.out.println("1.存款");
System.out.println("2.取款");
System.out.println("3.显示余额");
System.out.println("4.退出");
int xuanze = scan.nextInt();
if (xuanze == 1) {
double cunkuan = scan.nextDouble();
if(cunkuan > 0){
qian += cunkuan;
}
}else if(xuanze == 2){
double qukuan = scan.nextDouble();
if (qukuan > 0) {
qian -= qukuan;
}
}else if(xuanze == 3){
System.out.println("您的余额为:" + qian);
}else if(xuanze == 4){
System.out.println("退出程序");
tuichu = false;
}
}while(tuichu);
结果输出：
四，无限循环
"无限"循环结构的使用
格式：while(true) 或 for(;`;)
需求:从键盘输入不确定的整数，并判断读入的整数和负数的个数，输入为0时结束程序
思路: 像这种不确定循环次数，就称之为无限循环，在触发某个条件的时候结束循环，一定要有结束条件，不然就成死循环了，像这种不知道具体循环次数和范围的，用 while 循环来做会比较美观。
当 输入的数等于2的时候用berak结束循环。
Scanner scan = new Scanner(System.in);
int count1 = 0; // 记录正数个数
int count2 = 0; // 记录负数个数
while (true) {
int zhengshu = scan.nextInt();
if(zhengshu != 0){
if(zhengshu > 0){
count1++;
}else if(zhengshu < 0){
count2++;
}
}else if(zhengshu == 0){
break;
}
}
System.out.println("您输入的整数个数:" + count1);
System.out.println("您输入负数的个数：" + count2);
结果展示：
五，嵌套循环（或多重循环）
1. 嵌套循环的使用
嵌套循环的使用
- 嵌套循环：是指一个循环结构A的循环体是另一个循环结构B。
外层循环：循环结构A
内层循环：循环结构B - 说明:
1）内层循环充当了外层循环的循环体
2）对于两层嵌套循环来说，外层循环控制行数，内层循环控制列数
3）举例：外层循环执行m次，内层循环执行n次，则内层循环的循环体共执行 m * n 次。
4）实际开发中，我们不会出现三层以上的循环结构，三层的循环结构都很少见。
2. 嵌套循环案例：打印 * ，六列五行
思路：外层for 循环控制行数，内层for循环控制列数，我们先写外层的，要打印 5 行，i小于等于5就行了，然后是内层的，内层控制列数，要 6 列 直接 j 小于等于6就行了，然后在内层循环里面打印 *，然后这里有个细节，因为内层控制的是列，所以不要换行，一共六列，如果换行全程一行了，在在外层循环再换行。
for(int j = 1;j <= 5;j++){ // 用来控制行数
for(int i = 1;i<=6;i++){ // 用来控制列数
System.out.print("*");
}
System.out.println(); // 如果不换行还是在一行展示，如果换行了就是多行
}
结果输出：
3.嵌套循环案例：九九乘法表
思路：九九乘法表是 九行九列，那我们起手就是外层 循环，外层循环控制行，直接 i小于等于9，然后就是 内层循环了，操作列，这里我们要想列怎么写，内层循环的循环条件不好写，这个时候我们要找规律，可以发现，第一行只有一个 1 * 1 = 1，然后第二行是两个 2 * 1 =2，2*2 = 4，以此类推，所以我们会发现，每一行的行号是第几行那么就有多少列，我们直接就把 内层循环的循环条件设置为 j <= i 就可以了。然后打印出 System.out.print(i + "*"+ j + "=" + (i*j) + "\t"); \t 是制表符 空格，然后这里也是那个细节，列数不要换行，在外层循环的时候换行。
for(int i = 1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(i + "*"+ j + "=" + (i*j) + "\t");
}
System.out.println();
}
结果输出：
4. 嵌套循环案例：打印菱形
打印下面这个图像
我们得分成两部分写：上半部分和下半部分
i(第几行) j(第一行中-的个数) k(每一行中*的个数) 2i + j = 10 j = 5-i
* 1 4 1 k = 2 * i -1
*** 2 3 3
***** 3 2 5
******* 4 1 7
********* 5 0 9
思路：首先写外层循环，5行，那么直接 i 小于等于 5，然后是内层循环，分为了三个部分，相当于一行由三个部分组成第一个是左边的 - 然后中间是 * 然后还有右边的 - ，这个时候我们 我们就要看内层循环 的循环条件的规律了，我们先看 * 的，可以把每一行有多少个 * 给画出来，然后看规律上面画出来了，第一行是 1 个，第二行是3个，然后每往下一行都加两个，我们这个时候总结规律，看他们两个之间的线性关系，i 和 k 的，可以看到 2 * i -1 = k 比如是第 3行，2 * 3 -1 = 5，这样就行了，的循环条件写为 k <= 2 * i +1，然后就是看 - 的了，我们一样的来看规律 一共5行，第一行一个然后第五行 9 个*，然后从下到上，最后一行是没有 - 的因为占满了，然后往上一行也就是第四行有一个 -，然后第三行两个 – ，然后往上依次加1，这个时候就要看总结 - 的规律了，j = 5 - i，然后-的循环条件写为 j <= 5 - i，然后在外层循环换行。 然后上半部分就写完了。
注意：像这种内部的控制列，列一定不要换行。在外层循环的行换行。
for(int i =1;i <= 5;i++){ // 用来控制行
for(int j = 1;j <= 5-i ;j++){ // 用来打印 * 左边的-
System.out.print("-");
}
for(int k = 1;k <= 2 * i -1 ;k++){ //用来打印 *
System.out.print("*");
}
for(int x = 1;x <= 5-i ;x++){ //用来打印 * 右边的 -
System.out.print("-");
}
System.out.println();
}
上半部分图像
然后这里是下半部分的，跟上班部分是倒着的图像
i(第几行) j(第一行中-的个数) k(每一行中*的个数) 2i + j = 10 j = i-1
********* 1 0 9 k = 2 * (5-i) + 1
******* 2 1 7
***** 3 2 5
*** 4 3 3
* 5 4 1
思路：这里也是一样的看规律，起手就是外层循环先写，控制行数，i小于等于5，然后 是内存循环的三部分，还是按照两个之间的线性关系来写，循环条件。
for(int i = 1;i<=5;i++){ // 用来控制行
for(int j=1;j <= i-1;j++){ // 用来打印 * 左边的-
System.out.print("-");
}
for(int k=1;k<= 2*(5-i) + 1;k++){ //用来打印 *
System.out.print("*");
}
for(int x=1;x <= i-1;x++){ //用来打印 * 右边的 -
System.out.print("-");
}
System.out.println();
}
下班部分图像
下面是完整的图像和代码
for(int i =1;i <= 5;i++){ // 用来控制行
for(int j = 1;j <= 5-i ;j++){ // 用来打印 * 左边的-
System.out.print("-");
}
for(int k = 1;k <= 2 * i -1 ;k++){ //用来打印 *
System.out.print("*");
}
for(int x = 1;x <= 5-i ;x++){ //用来打印 * 右边的 -
System.out.print("-");
}
System.out.println();
}
for(int i = 1;i<=5;i++){ // 用来控制行
for(int j=1;j <= i-1;j++){ // 用来打印 * 左边的-
System.out.print("-");
}
for(int k=1;k<= 2*(5-i) + 1;k++){ //用来打印 *
System.out.print("*");
}
for(int x=1;x <= i-1;x++){ //用来打印 * 右边的 -
System.out.print("-");
}
System.out.println();
}
输出结果：
六，关键字break和continue的使用
使用 break 直接条出循环
for(int i =1;i<=10;i++){
if (i % 4 == 0) {
break; //如果使用 break 直接跳出循环，
}
System.out.println(i);
}
使用 continue 只是跳出符合当前条件的，类似 sql 中的where id != '123'
for(int i =1;i<=10;i++){
if (i % 4 == 0) {
continue; //如果是 continue 的话 只判定条件的，相当于sql中的 where id != '123' 一样
}
System.out.println(i);
1. 了解带标签的break和continue的使用
没加标签的 break
for(int i = 1;i<= 4;i++){
for(int j=1;i<=10;j++){
if(j % 4 ==0){
break;
}
System.out.print(i);
}
System.out.println();
}
加了标签的 break，使用方法就是 在循环前面加一个 标签，标签名随便写，然后break 后面跟上这个标签名就是退出指定的循环了，然后内层循环的时候到 4 的时候直接退出外层循环，然后外层循环只执行了一次，所以结果就是 123 了。
x:for(int i = 1;i<= 4;i++){
for(int j=1;i<=10;j++){
if(j % 4 ==0){
break x;
}
System.out.print(i);
}
System.out.println();
}
没加标签的 continue
七，算法练习
1. 100 以内的所有素数（质数）第一种方法
输出 100 以内的所有的素数（质数）？100000 以内的呢？
质数：只能被1和它本身整除的自然数，比如：2,3,5,7,11,13,17,19,23…
第一种解法：
思路：首先知道素数是什么，也就是除了1和本身，不能被任何数整除的数，所以先设置外层的初始值2，和循环条件 i 小于等于 100，然后来写内层循环，不管任何时候难写的都是内层循环，因为要了解 内层和外层的线性关系，因为是要 除了1和自身之外的，所以 j 肯定小于 i ，然后是从2开始，如果 i % j == 0 的话，那么说明，他被除1和自身之外的数整除了，用一个变量number来接收一下，然后在外层循环判定一下，如果 number 等于0的话那么说明刚刚内层里面 他没有被其他数整除，那么他就是质数，直接输出就可以了。
--> 换句话说，从2开始到这个自然数 - 1为止，不存在此自然数的约数
for (int i = 2;i<=100;i++){
int number = 0;
for (int j =2;j<i;j++){
if(i % j == 0){
number++;
}
}
if (number == 0){
System.out.println(i);
}
}
结果输出：
第二种解法：
思路：我们直接 设置一个布尔类型变量，初始值为true，如果 被1和自身之外的数给整除了，那么就 给他赋值为 false，然后 外层循环再 判断，如果 为 true 那么就是质数，直接输出，更有效率，对照上面的第一种解法来对比着看
for (int i = 2;i<=100;i++){
boolean isflag = true;
for (int j=2;j < i;j++){
if(i % j == 0){
isflag = false;
}
}
if (isflag){
System.out.println(i);
}
}
结果输出：可以看到这里的时间为 6330 毫秒
2. 100 以内的所有素数（质数）算法优化
优化思路：有两个地方可以优化，一个是 从2到9999是否能被除尽的时候，如果除以2除尽了说明以及不是质数了，但是他还是继续往后面判断，判断到 9999 那就没有必要，所以我们加了个判断，一旦他除尽了那么直接就break结束判断，然后还有一个优化点在 j 不用小于 i - 1,直接取 小于等于 i 的根号就可以了，比如 100 以内的质数，我们除以 2 然后另外一个约数是 50，除以4 另外一个约数 是 25，然后到10的时候也是10，所以说最中间这个也就是他的根号，那么我们就不用把所有的数判断完了，他们是对称的，这个是用来排除偶数的，可以迅速排除完，提升效率。这两个点优化之后，大概提升速度1000倍左右。
long start = System.currentTimeMillis(); //开始时间
ArrayList<Integer> arrayList = new ArrayList<Integer>(); //定义一个数组用来存放质数
int num = 0; // 定义一个变量用来记录 质数个数
boolean isFlag = true;
for(int i = 2;i<=100000;i++){
for(int j = 2;j<=Math.sqrt(i);j++){ //优化 对i加根号 缩小范围
if(i % j == 0){
isFlag = false;
break; //这里是 相当于 从2开始到9999，只要第一个 被2除尽了说明不是质数，直接退出，不然的话第一个都否定了还要一个一个的去判断完全用不着，这是大优化，时间从 6.4秒优化到了 0.5秒
}
}
if(isFlag){
arrayList.add(i);
num++;
}
isFlag = true; //重置变量
}
long end = System.currentTimeMillis(); // 结束时间
System.out.println("质数有这些:" + arrayList);
System.out.println("质数的个数为：" + num);
System.out.println("花费的时间为：" + (end - start) + "毫秒"); //6315 毫秒 --> 加上 break: 573 毫秒 --> 加上 i 开根号 9 毫秒
输出结果：
八，项目实战
1. 家庭记账软件
1）目 标
模拟实现一个基于文本界面的《家庭记账软件》
掌握初步的编程技巧和调试技巧
主要涉及以下知识点：
- 变量的定义
- 基本数据类型的使用
- 循环语句
- 分支语句
- 方法声明、调用和返回值的接收
- 简单的屏幕输出格式控制
2) 需求说明
- 模拟实现基于文本界面的《家庭记账软件》。
- 该软件能够记录家庭的收入、支出，并能够打印收支明细表。
- 项目采用分级菜单方式。主菜单如下：
-----------------家庭收支记账软件-----------------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)： - 假设家庭起始的生活基本金为10000元。
- 每次登记收入（菜单2）后，收入的金额应累加到基本金上，并记 录本次收入明细，以便后续的查询。
- 每次登记支出（菜单3）后，支出的金额应从基本金中扣除，并记 录本次支出明细，以便后续的查询。
- 查询收支明细（ 菜单1）时，将显示所有的收入、支出名细列表
需求说明1:
“收支明细”的界面及操作过程如下所示：
-----------------家庭收支记账软件-----------------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：1
-----------------当前收支明细记录-----------------
收支 账户金额 收支金额 说 明
收入 11000 1000 劳务费
支出 10200 800 物业费
提示：明细表格的对齐，可以简单使用制表符‘\t’来实现
需求说明2:
“登记收入”的界面及操作过程如下所示：
-----------------家庭收支记账软件-----------------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：2
本次收入金额：1000
本次收入说明：劳务费
需求说明3:
“登记支出”的界面及操作过程如下所示：
-----------------家庭收支记账软件-----------------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：3
本次支出金额：800
本次支出说明：物业费
需求说明4:
“退 出”的界面及操作过程如下所示：
-----------------家庭收支记账软件-----------------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：4
确认是否退出(Y/N)：
3) 设计流程
基本金和收支明细的记录
基本金的记录可以使用int类型的变量来实现：
int jine= 10000;
收支明细记录可以使用Sting类型的变量来实现，其初始值"" 如果有收入或者支出那么就存到这个变量里。例如：
String info= “”;
• 在登记收支时，将收支金额与jine相加或相减，收支记录直接串接到
info 后面即可
4) 代码实现
(1) for 循环实现
实现思路：首先为我们要先写 for 循环，循环初始值设一个布尔类型的值因为我们不知道具体的循环次数，然后循环条件为true，然后循环里面放我们的软件界面，然后我们要选择我们的输入的数字，进入对应的功能界面，第一个收入支出明细，第二个是收入的记录，第三个是支出的记录，第四个是直接退出软件，然后我们要在循环的外面定义两个变量，一个 jine 用来接收金额的初始值，一个 info 定义 第一个的收支明细字符串变量。我们应该先实现第二个和第三个需求，首先我们要在这个分支里定义一个键盘控制的，收入金额，然后判断如果收入大于0那么 jine += shouru 然后 info 也要接收信息 info += "收入\t" + jine + "\t" + shouru + "\t" + shuoming1 + "\n";然后 第二个需求就完成了，接下来是第三个需求 支出和收入的逻辑是一样，定义一个输出金额，然后 判断支出大于0 然后 jine -= zhichu 支出信息一样的存入 info 中 info += "支出\t" + jine + "\t" + zhichu + "\t" + shuoming2 + "\n"; 。然后现在需求1了，直接输入 info 就可以了。最后需求4，从键盘输入 Y/N ，如果是 Y 那么 isFlag = false 退出循环。
难点： info 变量字符串接收信息
package java_lainxi;
import java.util.Scanner;
// 家庭记账软件
public class Personal_Finance_Software {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int jine = 10000; // 初始化金额
String info = ""; // 记录收支的信息
for (boolean isFlag = true;isFlag;){
System.out.println("-----------------家庭收支记账软件-----------------\n");
System.out.println(" 1 收支明细");
System.out.println(" 2 登记收入");
System.out.println(" 3 登记支出");
System.out.println(" 4 退 出");
System.out.println(" 请选择(1-4)：");
int xuanze = scan.nextInt();
if(xuanze == 1){
System.out.println("-----------------当前收支明细记录-----------------\n");
System.out.println("收支\t账户金额\t收支金额\t说明\t");
System.out.println(info);
System.out.println("-------------------------------------------------\n");
} else if (xuanze == 2) {
System.out.print("本次收入金额:");
int shouru = scan.nextInt(); //输入收入金额
if (shouru > 0){
jine += shouru;
}
System.out.println("本次收入说明:");
String shuoming1 = scan.next(); // 输入收入备注
info += "收入\t" + jine + "\t" + shouru + "\t" + shuoming1 + "\n";
System.out.println("----------------登记完成------------------");
} else if (xuanze == 3) {
System.out.println("本次支出金额:");
int zhichu = scan.nextInt();
if (zhichu > 0){
jine -= zhichu;
}
System.out.println("本次支出说明:");
String shuoming2 = scan.next();
info += "支出\t" + jine + "\t" + zhichu + "\t" + shuoming2 + "\n";
System.out.println("----------------登记完成------------------");
} else if (xuanze == 4) {
System.out.println("确认是否退出(Y/N)：");
String isExit = scan.next();
if (isExit.equals("Y")){
isFlag = false;
}else{
System.out.println("请输入Y/N");
}
}
}
}
}
输出结果：
(2) while 循环实现
package java_lainxi;
import org.apache.spark.sql.sources.In;
import java.util.Scanner;
public class Personal_Finance_Software2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int jine = 10000; //用来存钱的初始值
String info = ""; //记录收支的信息
boolean isFlag = true; //用来控制循环退出
while (isFlag){
System.out.println("-----------------家庭收支记账软件-----------------\n");
System.out.println(" 1 收支明细");
System.out.println(" 2 登记收入");
System.out.println(" 3 登记支出");
System.out.println(" 4 退 出\n");
System.out.println(" 请选择(1-4):");
int xuanze = scan.nextInt();// 获取用户的选项
switch (xuanze){
case 1:
System.out.println("-----------------当前收支明细记录-----------------\n");
System.out.println("收支\t账户金额\t收支金额\t说 明\n");
System.out.println(info);
System.out.println("------------------------------------------------");
break;
case 2:
System.out.print("本次收入金额:");
int shouru = scan.nextInt();
if (shouru > 0){
jine += shouru;
}
System.out.println("本次收入说明:");
String shuoming = scan.next();
info += "收支\t" + jine + "\t" + shouru + "\t" + shuoming + "\n";
System.out.println("-----------------登记完成-----------------------");
break;
case 3:
System.out.println("本次支出金额:");
int zhichu = scan.nextInt(); // 支出的金额
if (zhichu > 0){
jine -= zhichu;
}
System.out.println("本次支出说明:");
String shuoming2 = scan.next();
info += "支出\t" + jine + "\t" + zhichu + "\t" + shuoming2 + "\n";
System.out.println("-----------------登记完成-----------------------");
break;
case 4:
System.out.println("确认是否退出(Y/N):");
String isExit = scan.next();
if(isExit.equals("Y")){
isFlag = false;
}
break;
}
}
}
}
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
