【原】Java学习笔记007 - 流程控制
package cn.temptation;
public class Sample01 {
public static void main(String[] args) {
// for循环
// 格式
// for (int i = 初始值; i < value; i++) {
//
// }
// 口诀：左初值、右步长、条件在中间、处理在内部
// 1、左初值：声明一个变量并给变量赋值
// 2、右步长：控制左边声明的变量的变化幅度，为了让循环有跳出的可能
// 3、条件在中间：中间部分是循环的条件，当条件满足时，执行循环体中的语句；不满足时就不执行
// 需求：使用for循环输出1~5
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
// for循环执行顺序：（面试时可能被问到的问题）
// 可以结合调试模式查看变量的值的变化，得到如下结论：
// 1、第一次循环----->先做左初值的变量声明 和 赋初始化值
// 2、 ----->判断条件是否满足
// 3、 ----->进入到循环体中执行语句
// 4、 ----->执行完循环体中的语句后，再做右步长，控制左边变量的变化幅度
// 5、第二次循环----->从这次开始就不再做左初值，直接判断条件是否满足
// 6、 ----->进入到循环体中执行语句
// 7、 ----->执行完循环体中的语句后，再做右步长，控制左边变量的变化幅度
// 8、...
// 9、 ----->直到某次循环条件不再满足，跳出循环
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// 需求：分别使用while循环 和 for循环输出 1~5
// while循环
int i = 1;
while (i <= 5) {
System.out.println(i);
i++;
}
// for循环
for (int j = 1; j <= 5; j++) {
System.out.println(j);
}
// 对比一下while循环 和 for循环
// 发现 while 循环 和 for 循环 差不多，只是把多行语句合并到一行里了
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
// 需求：使用for循环输出1~100
// 需求：使用for循环计算1+2+...+100
// 左初值：初始值由开发人员自己设置
// 写法1
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
// 写法2
for (int i = 0; i < 100; i++) {
System.out.println(i + 1);
}
// 写法3
for (int i = -1; i < 99; i++) {
System.out.println(i + 2);
}
// 注意：第11行、第16行、第21行都使用了变量i，之前讲变量名不能重复，这里为何没有提示语法错误？
// 因为变量的作用范围（作用域），这里的for循环中定义的变量，只能在该循环中可以使用，超出了该循环范围就无法使用了
// 语法错误：i cannot be resolved to a variable
// System.out.println(i);
// 定义总和的变量
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println("1+2+...+100=" + sum);
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// 需求：使用for循环列出1~100之间的奇数
// 写法1、奇数的间隔为2
// for (int i = 1; i < 100; i += 2) {
// System.out.println(i);
// }
for (int i = 1; i < 100; i = i + 2) {
System.out.println(i);
}
// 写法2、奇数是和2求余为1的数
for (int i = 1; i <= 100; i++) {
if (i % 2 == 1) {
System.out.println(i);
}
}
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
// 需求：计算1~100之间的偶数的和
// int sum = 0;
// 写法1、偶数的间隔为2
// for (int i = 0; i <= 100; i += 2) {
// sum += i;
// }
// 写法2、偶数是和2求余数为0的数
// for (int i = 0; i <= 100; i++) {
// if (i % 2 == 0) {
// sum += i;
// }
// }
// System.out.println("1~100之间的偶数的和为：" + sum);
// 作为和的变量sum也在for循环中定义，如何写？
// 变量sum在循环结构的头部进行声明和赋初始化值，在循环体内可以使用它，但是在循环体外无法访问它
// for (int i = 0, sum = 0; i <= 100; i += 2) {
// sum += i;
// // 添加选择结构，让循环在最后一次输出结果
// if (i == 100) {
// System.out.println("1~100之间的偶数的和为：" + sum);
// }
// }
// System.out.println("1~100之间的偶数的和为：" + sum);
// 注意：如下写法，变量sum会在每次循环时重新设置为0，也就不会保存之前循环操作的结果
// 这也从侧面说明左初值中的内容只在第一次循环时执行，后续循环时都不会再执行
for (int i = 0; i <= 100; i++) {
int sum = 0;
sum += i;
System.out.println("1~100之间的偶数的和为：" + sum);
}
}
}
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
// 需求：使用for循环统计100~999之间的水仙花数并计算有多少个？
// 规则：以三位数字为例，数字的值 = (百位上的数字 * 百位上的数字 * 百位上的数字)
// + (十位上的数字 * 十位上的数字 * 十位上的数字)
// + (个位上的数字 * 个位上的数字 * 个位上的数字)，则称为是一个水仙花数
// 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3
// 定义统计用个数变量
int count = 0;
for (int number = 100; number <= 999; number++) {
// 获取个位数字
int i = number / 1 % 10;
// 获取十位数字
int j = number / 10 % 10;
// 获取百位数字
int k = number / 100 % 10;
if (number == i * i * i + j * j * j + k * k * k) {
// 满足规则的数字输出
System.out.println(number);
count++;
}
}
System.out.println("100~999之间的水仙花数并计算有" + count + "个");
}
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
// 需求：使用for循环计算10的阶乘
// 阶乘：10! = 10 * 9 * 8 * 7 * ... * 1
// 定义结果变量
int result = 1;
// 写法1
// for (int i = 1; i <= 10; i++) {
// result *= i;
// }
// 写法2
for (int i = 10; i >= 1; i--) {
result *= i;
}
System.out.println("10的阶乘为：" + result);
// 注意：编程动手之前，先考虑一下程序执行结果的数值范围，选择合适的数据类型
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// 需求：使用for循环解决百钱百鸡问题：母鸡一只5元，公鸡一只3元，小鸡三只1元，有100元，如何买到100只鸡？母鸡多少只？公鸡多少只？小鸡多少只？（母鸡、公鸡、小鸡都有）
// 思路：
// 从需求中得到一些等式
// 母鸡数量 + 公鸡数量 + 小鸡数量 = 100
// 母鸡单价 * 母鸡数量 + 公鸡单价 * 公鸡数量 + 小鸡单价 * 小鸡数量 = 100
// 小鸡数量是3的倍数
// 运用"穷举法"
// 如果买1只母鸡，再买1只公鸡，还能买多少只小鸡
// 如果买1只母鸡，再买2只公鸡，还能买多少只小鸡
// ...
// 如果买2只母鸡，再买1只公鸡，还能买多少只小鸡
// 如果买2只母鸡，再买2只公鸡，还能买多少只小鸡
// ...
System.out.println("使用for循环求解百钱百鸡问题：");
for (int i = 1; i < 20; i++) { // 计算母鸡
for (int j = 1; j < 33; j++) { // 计算公鸡
// 小鸡数量
int k = 100 - i - j;
if ((5 * i + 3 * j + k / 3 == 100) && (k % 3 == 0)) {
System.out.println("母鸡：" + i + "只，公鸡：" + j + "只，小鸡：" + k + "只");
}
}
}
}
}
package cn.temptation;
public class Sample09 {
public static void main(String[] args) {
// 需求：打印显示 4 * 4 正方形的点阵
// 写法1、最原始的写法
// System.out.println("****");
// System.out.println("****");
// System.out.println("****");
// System.out.println("****");
// 写法2、借助于 \r \n实现换行的操作
// System.out.println("****\r\n****\r\n****\r\n****");
// 思路：
// 1、在一行中把*号输出4次，形成****
// 2、再在3个不同的行上重复步骤1的操作
// 写法3、分步循环操作
// for (int i = 0; i < 4; i++) {
// System.out.print("*");
// }
// System.out.println();
// for (int i = 0; i < 4; i++) {
// System.out.print("*");
// }
// System.out.println();
// for (int i = 0; i < 4; i++) {
// System.out.print("*");
// }
// System.out.println();
// for (int i = 0; i < 4; i++) {
// System.out.print("*");
// }
// System.out.println();
// 写法4、针对写法3的改进，因为有发现相同的事情重复做，自然考虑使用循环
// 循环的嵌套
// 内部的操作时在一行中循环输出4个星号，把内部的操作作为一个整体，在外部再重复内部的这个操作3次
// 外部循环操作：重复内部的这个操作4次
for (int j = 0; j < 4; j++) {
// 内部循环操作：在一行中循环输出4个星号
for (int i = 0; i < 4; i++) {
System.out.print("*");
}
System.out.println();
}
}
}
package cn.temptation;
public class Sample10 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *
// **
// ***
// ****
// *****
// 思路：找规律
// 1、第1行1个星号
// 2、第2行2个星号
// 3、第3行3个星号
// 4、第4行4个星号
// 5、第5行5个星号
// 分步操作
// for (int i = 0; i < 1; i++) {
// System.out.print("*");
// }
// // 换行
// System.out.println();
// for (int i = 0; i < 2; i++) {
// System.out.print("*");
// }
// // 换行
// System.out.println();
// for (int i = 0; i < 3; i++) {
// System.out.print("*");
// }
// // 换行
// System.out.println();
// for (int i = 0; i < 4; i++) {
// System.out.print("*");
// }
// // 换行
// System.out.println();
// for (int i = 0; i < 5; i++) {
// System.out.print("*");
// }
// // 换行
// System.out.println();
// 看到有重复的操作，考虑使用循环
// 看见有变化的量：1、2、3、4、5，考虑使用变量
// 通过找规律，我们发现这变量的值和其所在的行号一致
// 行号是什么？行号就是外层循环操作的当前次操作的数字，且这个数字是提供给内层循环来使用的数字（用于循环条件的控制）
// 写法1
// 外层循环
for (int i = 1; i <= 5; i++) {
// 内层循环
for (int j = 0; j < i; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
// 写法2
for (int i = 0; i < 5; i++) {
for (int j = 0; j <= i; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample11 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *****
// ****
// ***
// **
// *
// 思路：找规律
// 1、第1行5个星号
// 2、第2行4个星号
// 3、第3行3个星号
// 4、第4行2个星号
// 5、第5行1个星号
// 写法1
for (int i = 0; i < 5; i++) {
for (int j = 4; j >= i; j--) {
System.out.print("*");
}
// 换行
System.out.println();
}
// 写法2
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5 - i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
package cn.temptation;
public class Sample12 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *
// **
// ***
// ****
// *****
// 思路：
// 1、星号还是打印一样的星号
// 2、在每一行输出星号之前，先输出了空格
// 3、一个较复杂的问题分解为两个简单的问题来处理：分解为每行中先输出空格，再输出星号
for (int i = 0; i < 5; i++) {
// 输出空格的处理
for (int j = 0; j < 4 - i; j++) {
System.out.print(" ");
}
// 输出星号的处理
for (int j = 0; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
package cn.temptation;
public class Sample13 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *****
// ****
// ***
// **
// *
for (int i = 0; i < 5; i++) {
// 打印空格
for (int j = 0; j < i; j++) {
System.out.print(" ");
}
// 打印星号
for (int j = 0; j < 5 - i; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample14 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *
// ***
// *****
// *******
// *********
for (int i = 0; i < 5; i++) {
// 打印空格
for (int j = 0; j < 4 - i; j++) {
System.out.print(" ");
}
// 打印星号
for (int j = 1; j <= i * 2 + 1; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample15 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *
// **
// ***
// ****
// *****
// ****
// ***
// **
// *
// 思路：不妨把这个问题分解为打印上部分 和 下部分
// 打印上部分
for (int i = 0; i < 5; i++) {
for (int j = 0; j <= i; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
// 打印下部分
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4 - i; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample16 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *
// **
// ***
// ****
// *****
// ****
// ***
// **
// *
// 思路：不妨把这个问题分解为打印上部分 和 下部分
// 打印上部分
for (int i = 0; i < 5; i++) {
// 打印空格
for (int j = 0; j < 4 - i; j++) {
System.out.print(" ");
}
// 打印星号
for (int j = 0; j <= i; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
// 打印下部分
for (int i = 0; i < 4; i++) {
// 打印空格
for (int j = 0; j <= i; j++) {
System.out.print(" ");
}
// 打印星号
for (int j = 0; j < 4 - i; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample17 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *
// ***
// *****
// *******
// *********
// *******
// *****
// ***
// *
// 思路：不妨把这个问题分解为打印上部分 和 下部分
// 打印上部分
for (int i = 0; i < 5; i++) {
// 打印空格
for (int j = 0; j < 4 - i; j++) {
System.out.print(" ");
}
// 打印星号
for (int j = 1; j <= i * 2 + 1; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
// 打印下部分
for (int i = 0; i < 4; i++) {
// 打印空格
for (int j = 0; j <= i; j++) {
System.out.print(" ");
}
// 打印星号
for (int j = 0; j <= 7 - i * 2 - 1; j++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample18 {
public static void main(String[] args) {
// 需求：使用for循环打印如下图形
// *
// * *
// * *
// * *
// * *
// * *
// * *
// * *
// *
// 思路：不妨把这个问题分解为打印上部分 和 下部分
// 打印上部分
for (int i = 0; i < 5; i++) {
// 打印空格
for (int j = 0; j < 4 - i; j++) {
System.out.print(" ");
}
// 打印星号
System.out.print("*");
if (i != 0) { // 第一行不执行
// 打印空格
for (int j = 0; j < 2 * i - 1; j++) {
System.out.print(" ");
}
// 打印星号
System.out.print("*");
}
// 换行
System.out.println();
}
// 打印下部分
for (int i = 0; i < 4; i++) {
// 打印空格
for (int j = 0; j <= i; j++) {
System.out.print(" ");
}
// 打印星号
System.out.print("*");
if (i != 3) { // 最后一行不执行
// 打印空格
for (int j = 0; j < 5 - 2 * i; j++) {
System.out.print(" ");
}
// 打印星号
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample19 {
public static void main(String[] args) {
// 需求：使用for循环打印九九乘法口诀表
// 思路：
// 1、把没有遇见过的问题转换为遇见过的问题
// 2、只要把星号替换为算术表达式即可
// 3、使用"\t"实现制表符的效果
System.out.println("-----九九乘法口诀表-----");
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
// System.out.print("*" + "\t");
System.out.print(j + "*" + i + "=" + (i * j) + "\t");
}
// 换行
System.out.println();
}
}
}
package cn.temptation;
public class Sample20 {
public static void main(String[] args) {
// break语句
// 1、switch语句中，结合case条件 或是 default语句，起的是跳出选择结构的作用
// 2、break用在循环中，起的跳出循环结构的作用，在某次循环执行过程中执行到break语句后跳出了循环，break之后的语句是执行不到的
// int i = 2;
// switch (i) {
// case 1:
// System.out.println("i的值为1");
// break;
// case 2:
// System.out.println("i的值为2");
// break;
// default:
// break;
// }
// while (i < 5) {
// System.out.println(i);
// i++;
// break;
// // 语法错误：Unreachable code
// System.out.println("这是break语句之后的语句");
// }
// Dead Code 描述右步长部分为死代码
// 再次从侧面证明了右步长是在循环体内的语句执行结束后去执行的
for (int j = 0; j < 3; j++) {
System.out.println(j);
break;
// 语法错误：Unreachable code
// System.out.println("这是break语句之后的语句");
}
// 注意：下句也是break语句后的语句，但是不受break语句的影响，因为break语句是for循环中的语句，是跳出循环的操作
System.out.println("如果看到这句，说明循环结束了");
}
}
package cn.temptation;
public class Sample21 {
public static void main(String[] args) {
// continue语句
// 1、continue语句不能用在循环以外的结构中
// 2、循环中的continue语句之后的语句会提示语法错误：无法到达的代码
// 3、continue语句表示跳出当前当次循环
int i = 2;
if (i == 3) {
System.out.println("i等于3");
// 语法错误：continue cannot be used outside of a loop
// continue;
}
// while (i < 5) {
// System.out.println(i);
// continue;
// // 语法错误：Unreachable code
//// System.out.println("continue语句之后的语句");
// }
// for (int j = 0; j < 5; j++) {
// if (j == 2) {
// continue;
// }
// System.out.println(j);
// }
// 对比break语句 和 continue语句的效果
// 结论：break语句跳出循环（后续循环条件满足也不执行了）；continue语句跳出当前当次循环
for (int j = 0; j < 5; j++) {
if (j == 2) {
break;
}
System.out.println(j);
}
}
}
package cn.temptation;
public class Sample22 {
public static void main(String[] args) {
// 循环中死循环写法的总结
// while (true) {
// System.out.println("while死循环的写法");
// }
// do {
// System.out.println("do...while死循环的写法");
// } while (true);
// for (;;) {
// System.out.println("for死循环的写法");
// }
// 根据while 和 for 死循环的写法，稍作变形，侧面证明while结构 和 for结构是一样的
int i = 2;
// while (i < 5) {
// System.out.println(i);
// i++;
// }
for (; i < 5;) {
System.out.println(i);
i++;
}
}
}
【原】Java学习笔记007 - 流程控制的更多相关文章
- 【原】Java学习笔记005 - 流程控制
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 程序的流程控制(流 ...
- 【原】Java学习笔记006 - 流程控制
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 需求:写一万次&q ...
- Java学习笔记五——流程控制
分支结构 Java提供了两种常见的分支控制结构:if语句和switch语句. if语句 if语句使用布尔值或布尔表达式(表达式结果为布尔值),if语句有3中形式: 第一种形式: if (5 > ...
- Java学习笔记之---流程控制语句
Java学习笔记之---流程控制语句 (一)循环语句 (1)if语句 if(布尔表达式){ //如果布尔表达式为true将执行的语句 } if(i%2!=0){ System.out.println( ...
- Python学习笔记 - day4 - 流程控制
Python流程控制 Python中的流程控制主要包含两部分:条件判断和循环. Python的缩进和语法 为什么要在这里说缩进和语法,是因为将要学习的条件判断和分支将会涉及到多行代码,在java.c等 ...
- PYTHON 学习笔记2 流程控制工具以及函数定义、匿名函数
前言 在上一节的学习中.已经介绍了几种基本类型.包括字符串的定义,以及字符串中索引.切片.字符串拼接的使用方法.以及基本的整形数据运算.一些之前都没有了解过的运算符.比如 ** 乘方 //整数除法等. ...
- JavaSE学习笔记03流程控制
Java流程控制 1.顺序结构 java的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句往下执行. 顺序结构是最简单的算法结构,它是任何一个算法都离不开的一种基本算法结构. 2. 选择结构 ...
- C#学习笔记_04_流程控制
04_流程控制 程序的执行结构: 顺序结构 分支结构 循环结构 可以通过某些特定的控制语句来控制代码的执行结构 分支流程控制 if else 基本语法 可以只有if没有else,但是不能没有if只有e ...
- 0039 Java学习笔记-多线程-线程控制、线程组
join线程 假如A线程要B线程去完成一项任务,在B线程完成返回之前,不进行下一步执行,那么就可以调用B线程的join()方法 join()方法的重载: join():等待不限时间 join(long ...
随机推荐
- Underscore.js 源码学习笔记（下）
上接 Underscore.js 源码学习笔记(上) === 756 行开始 函数部分. var executeBound = function(sourceFunc, boundFunc, cont ...
- 【机器学习】--线性回归中soft-max从初始到应用
一.前述 Soft-Max是做多分类的,本身是哪个类别的概率大,结果就为对应的类别.为什么称之为Soft判别,原因是归一化之后的概率选择最大的作为结果,而不是只根据分子. 二.原理 sigmod函数: ...
- 4.DOM
定义 文档对象模型(Document Object Model)是一种用于HTML和XML文档的编程接口. 查找元素 1.直接查找 document.getElementById 根据ID获取一个标签 ...
- api-ms-win-crt-process-l1-1-0.dll 丢失的处理，遇到问题和完美解决
api-ms-win-crt-process-l1-1-0.dll 丢失的处理 简介 在换了新电脑后,一些环境需要重新搭建,本以为是个小case,没想到竟然遇到了各种拦路虎. 在成功安装Python3 ...
- DOM事件第二弹（UIEvent事件）
此文章主要总结UIEvent相关的事件,如有不对的地方,欢迎指正. 一.uitls.js(绑定事件公共类) var fixs = { 'focusin': { standard: 'focus', i ...
- 前端笔记之jQuery（下）事件&节点操作&净位置&拖拽&页面卷动值&遍历JSON
一.监听事件大全 1.1 JavaScript事件 onblur 元素失去焦点 onchange 用户改变域的内容 onclick 鼠标点击某个对象 ondblclick 鼠标双击某个对象 onfoc ...
- HBase查询优化之Short-Circuit Local Reads
1.概述 在<HBase查询优化>一文中,介绍了基于HBase层面的读取优化.由于HBase的实际数据是以HFile的形式,存储在HDFS上.那么,HDFS层面也有它自己的优化点,即:Sh ...
- 【转载】ASP.NET Core 依赖注入
本文转自:http://www.jessetalk.cn/2017/11/06/di-in-aspnetcore/ 为什么要写这个博客 DI在.NET Core里面被提到了一个非常重要的位置, 这篇文 ...
- PC逆向之代码还原技术,第一讲基本数据类型在内存中的表现形式.浮点,指针寻址公式
目录 代码还原技术 一丶简介代码还原 二丶代码还原中的数据类型表现形式 1.整数类型 2.无符号整数 3.有符号整数 4.浮点数数据类型 5.浮点编码 4.Double类型解析. 三丶浮点汇编 1.浮 ...
- windows资源管理器多标签打开 windows文件夹多标签浏览 浏览器tab页面一样浏览文件夹 clover win8 win10 报错 无响应问题怎么解决 clover卡死 clover怎么换皮肤
大家都知道,我们打开一堆文件夹的时候,是什么样子 “厚厚的一叠”图标堆叠在一起的,非常的不方便 那么,是不是可以像浏览器一样的tab页面展示呢? 答案是可以的 安装好就是这样子的 是不是方便漂亮了很多 ...