版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://mp.csdn.net/mdeditor/100662793

绪言

最近开始学习Java，主要教材是廖雪峰老师的Java教程。为了巩固学习的成果，并作为以后查阅的参考，我计划写一系列学习笔记。
这是本系列的第三篇 – 流程控制。

本节我们将介绍Java程序的基础知识，包括：

输入和输出
if判断
switch多重选择
while循环
do while循环
for循环
break和continue

输入和输出

输出

我们经常使用System.out.println()来向屏幕输出一些内容。

println是print line的缩写，表示输出并换行。如果输出后不想换行，可以用print()。
举个栗子：

public class Main {public static void main(String[] args) {System.out.print("A,");System.out.print("B,");System.out.print("C.");System.out.println();System.out.println("END");}
}

结果：

A,B,C.
END

格式化输出

如果要把数据显示成我们期望的格式，就需要使用格式化输出的功能。格式化输出使用System.out.printf()，通过使用占位符%?，printf()可以把后面的参数格式化成指定格式。举个栗子：

public class Main {public static void main(String[] args) {double d = 3.1415926;System.out.printf("%.2f\n", d); // 显示两位小数3.14System.out.printf("%.4f\n", d); // 显示4位小数3.1416}
}

结果：

3.14
3.1416

Java的格式化功能提供了多种占位符，可以把各种数据类型“格式化”成指定的字符串：

占位符	说明
%d	格式化输出整数
%x	格式化输出十六进制整数
%f	格式化输出浮点数
%e	格式化输出科学计数法表示的浮点数
%s	格式化字符串

注意：由于%表示占位符，因此，连续两个%%表示一个%字符本身。

占位符本身还可以有更详细的格式化参数。下面的例子把一个整数格式化成十六进制，并用0补足8位：

public class Main {public static void main(String[] args) {int n = 12345000;System.out.printf("n=%d, hex=%08x", n, n); // 注意，两个%占位符必须传入两个数}
}

结果：

n=12345000, hex=00bc5ea8

输入

和输出相比，Java的输入就要复杂得多。

先看一个从控制台读取一个字符串和一个整数的例子：

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in); // 创建Scanner对象System.out.print("Input your name: "); // 打印提示String name = scanner.nextLine(); // 读取一行输入并获取字符串System.out.print("Input your age: "); // 打印提示int age = scanner.nextInt(); // 读取一行输入并获取整数System.out.printf("Hi, %s, you are %d\n", name, age); // 格式化输出}
}

首先，通过import语句导入java.util.Scanner，import是导入某个类的语句，必须放到Java源代码的开头，后面在Java的package中会学到如何使用import。

然后，创建Scanner对象并传入System.in。System.out代表标准输出流，而System.in代表标准输入流。直接使用System.in读取用户输入虽然是可以的，但需要更复杂的代码，而通过Scanner就可以简化后续的代码。

有了Scanner对象后，要读取用户输入的字符串，使用scanner.nextLine()，要读取用户输入的整数，使用scanner.nextInt()。Scanner会自动转换数据类型，因此不必手动转换。

if判断

在Java程序中，如果要根据条件来决定是否执行某一段代码，就需要if语句。

if语句的基本语法是：

if (条件) {// 条件满足时执行
}

根据if的计算结果（true还是false），JVM决定是否执行if语句块（即花括号{}包含的所有语句）。

if语句包含的块可以包含多条语句，当if语句块只有一行语句时，可以省略花括号{}。但是不建议这样做，如果想给if语句块增加一条语句，由于使用缩进格式，很容易把两行语句都看成if语句的执行块，而实际只有第一行语句会被程序看做if的执行块。

else

if语句还可以编写一个else { … }，当条件判断为false时，将执行else的语句块。
举个栗子：

public class Main {public static void main(String[] args) {int n = 70;if (n >= 60) {System.out.println("及格了");} else {System.out.println("挂科了");}System.out.println("END");}
}

结果：

及格了

还可以用多个if … else if …串联。例如：

public class Main {public static void main(String[] args) {int n = 70;if (n >= 90) {System.out.println("优秀");} else if (n >= 60) {System.out.println("及格了");} else {System.out.println("挂科了");}System.out.println("END");}
}

结果：

及格了

判断引用类型相等

在Java中，判断值类型的变量是否相等，可以使用==运算符。但是，判断引用类型的变量是否相等，==表示“引用是否相等”，或者说，是否指向同一个对象。例如，下面的两个String类型，它们的内容是相同的，但是，分别指向不同的对象，用==判断，结果为false：

public class Main {public static void main(String[] args) {String s1 = "hello";String s2 = "HELLO".toLowerCase();System.out.println(s1);System.out.println(s2);if (s1 == s2) {System.out.println("s1 == s2");} else {System.out.println("s1 != s2");}}
}

结果：

hello
hello
s1 != s2

要判断引用类型的变量内容是否相等，必须使用equals()方法：

public class Main {public static void main(String[] args) {String s1 = "hello";String s2 = "HELLO".toLowerCase();System.out.println(s1);System.out.println(s2);if (s1.equals(s2)) {System.out.println("s1 equals s2");} else {System.out.println("s1 not equals s2");}}
}

结果：

hello
hello
s1 equals s2

switch多重选择

switch语句根据switch (表达式)计算的结果，跳转到匹配的case结果，然后继续执行后续语句，直到遇到break结束执行。
举个栗子：

public class Main {public static void main(String[] args) {int option = 1;switch (option) {case 1:System.out.println("Selected 1");break;case 2:System.out.println("Selected 2");break;case 3:System.out.println("Selected 3");break;}}
}

结果：

Selected 1

如果option的值没有匹配到任何case，例如option = 99，那么，switch语句不会执行任何语句。这时，可以给switch语句加一个default，当没有匹配到任何case时，执行default：

public class Main {public static void main(String[] args) {int option = 99;switch (option) {case 1:System.out.println("Selected 1");break;case 2:System.out.println("Selected 2");break;case 3:System.out.println("Selected 3");break;default:System.out.println("Not selected");break;}}
}

结果：

Not selected

注意，在switch语句中对每个case都要有break语句。

使用switch时，注意case语句并没有花括号{}，而且，case语句具有“穿透性”，漏写break将导致意想不到的结果：

public class Main {public static void main(String[] args) {int option = 2;switch (option) {case 1:System.out.println("Selected 1");case 2:System.out.println("Selected 2");case 3:System.out.println("Selected 3");default:System.out.println("Not selected");}}
}

结果：

Selected 2
Selected 3
Not selected

如果有几个case语句执行的是同一组语句块，可以这么写：

public class Main {public static void main(String[] args) {int option = 2;switch (option) {case 1:System.out.println("Selected 1");break;case 2:case 3:System.out.println("Selected 2, 3");break;default:System.out.println("Not selected");break;}}
}

switch表达式

使用switch时，如果遗漏了break，就会造成严重的逻辑错误，而且不易在源代码中发现错误。从Java 12开始，switch语句升级为更简洁的表达式语法，使用类似模式匹配（Pattern Matching）的方法，保证只有一种路径会被执行，并且不需要break语句：

public class Main {public static void main(String[] args) {String fruit = "apple";switch (fruit) {case "apple" -> System.out.println("Selected apple");case "pear" -> System.out.println("Selected pear");case "mango" -> {System.out.println("Selected mango");System.out.println("Good choice!");}default -> System.out.println("No fruit selected");}}
}

结果：

Selected apple

注意新语法使用->，如果有多条语句，需要用{}括起来。不要写break语句，因为新语法只会执行匹配的语句，没有穿透效应。

使用新的switch语法，还可以直接返回值。

public class Main {public static void main(String[] args) {String fruit = "apple";int opt = switch (fruit) {case "apple" -> 1;case "pear", "mango" -> 2;default -> 0;}; // 注意赋值语句要以;结束System.out.println("opt = " + opt);}
}

结果：

opt = 1

while循环

循环语句就是让计算机根据条件做循环计算，在条件满足时继续循环，条件不满足时退出循环。

while条件循环的基本用法是：

while (条件表达式) {循环语句
}
// 继续执行后续代码

while循环在每次循环开始前，首先判断条件是否成立。如果计算结果为true，就把循环体内的语句执行一遍，如果计算结果为false，那就直接跳到while循环的末尾，继续往下执行。

举个栗子：
public class Main {
public static void main(String[] args) {
int sum = 0; // 累加的和，初始化为0
int n = 1;
while (n <= 100) { // 循环条件是n <= 100
sum = sum + n; // 把n累加到sum中
n ++; // n自身加1
}
System.out.println(sum);
}
}
结果：

注意1：while循环是先判断循环条件，再循环，因此，有可能一次循环都不做。
注意2：对于循环条件判断，以及自增变量的处理，要特别注意边界条件。
举个栗子：

public class Main {public static void main(String[] args) {int sum = 0;int n = 0;while (n <= 100) {n ++;sum = sum + n;}System.out.println(sum);}
}

结果变成了：

注意3：如果循环条件永远满足，那这个循环就变成了死循环。
举个栗子：

public class Main {public static void main(String[] args) {int sum = 0;int n = 1;while (n > 0) {sum = sum + n;n ++;}System.out.println(n); // -2147483648System.out.println(sum);}
}

但是在这个栗子中，Java的int类型有最大值，达到最大值后，再加1会变成负数，结果，意外退出了while循环。

do while循环

在Java中，while循环是先判断循环条件，再执行循环。而另一种do while循环则是先执行循环，再判断条件，条件满足时继续循环，条件不满足时退出。它的用法是：

do {执行循环语句
} while (条件表达式);

举个栗子：

public class Main {public static void main(String[] args) {int sum = 0;int n = 1;do {sum = sum + n;n ++;} while (n <= 100);System.out.println(sum);}
}

结果：

可见，do while循环会至少循环一次。

for循环

for循环使用计数器实现循环。for循环会先初始化计数器，然后，在每次循环前检测循环条件，在每次循环后更新计数器。计数器变量通常命名为i。

还是这个栗子：

public class Main {public static void main(String[] args) {int sum = 0;for (int i=1; i<=100; i++) {sum = sum + i;}System.out.println(sum);}
}

结果：

在for循环执行前，会先执行初始化语句int i=1，它定义了计数器变量i并赋初始值为1，然后，循环前先检查循环条件i<=100，循环后自动执行i++，因此，和while循环相比，for循环把更新计数器的代码统一放到了一起。在for循环的循环体内部，不需要去更新变量i。

利用for循环也可以对一个整型数组的所有元素求和，可以用for循环实现：

public class Main {public static void main(String[] args) {int[] ns = { 1, 4, 9, 16, 25 };int sum = 0;for (int i=0; i<ns.length; i++) {System.out.println("i = " + i + ", ns[i] = " + ns[i]);sum = sum + ns[i];}System.out.println("sum = " + sum);}
}

结果：

i = 0, ns[i] = 1
i = 1, ns[i] = 4
i = 2, ns[i] = 9
i = 3, ns[i] = 16
i = 4, ns[i] = 25
sum = 55

注意：在for循环中，不要修改计数器的值。计数器的初始化、判断条件、每次循环后的更新条件统一放到for()语句中可以一目了然。

灵活使用for循环

for循环还可以缺少初始化语句、循环条件和每次循环更新语句，例如：

/ 什么都不设置:
for (;;) {...
}

通常不推荐这样写，但是，某些情况下，是可以省略for循环的某些语句的。

for each循环

for each循环可以更简单地遍历数组：

public class Main {public static void main(String[] args) {int[] ns = { 1, 4, 9, 16, 25 };for (int n : ns) {System.out.println(n);}}
}

结果：

for each循环的写法也更简洁。但是，for each循环无法指定遍历顺序，也无法获取数组的索引。

除了数组外，for each循环能够遍历所有“可迭代”的数据类型，包括后面会介绍的List、Map等。

break和continue

break

在循环过程中，可以使用break语句跳出当前循环。
举个栗子：

public class Main {public static void main(String[] args) {int sum = 0;for (int i=1; ; i++) {sum = sum + i;if (i == 100) {break;}}System.out.println(sum);}
}

结果：

使用for循环计算从1到100时，我们并没有在for()中设置循环退出的检测条件。但是，在循环内部，我们用if判断，如果i==100，就通过break退出循环。

因此，break语句通常都是配合if语句使用。要特别注意，break语句总是跳出自己所在的那一层循环。例如：

public class Main {public static void main(String[] args) {for (int i=1; i<=10; i++) {System.out.println("i = " + i);for (int j=1; j<=10; j++) {System.out.println("j = " + j);if (j >= i) {break;}}// break跳到这里System.out.println("breaked");}}
}

结果：

i = 1
j = 1
breaked
i = 2
j = 1
j = 2
breaked
i = 3
j = 1
j = 2
j = 3
breaked
i = 4
j = 1
j = 2
j = 3
j = 4
breaked
i = 5
j = 1
j = 2
j = 3
j = 4
j = 5
breaked
i = 6
j = 1
j = 2
j = 3
j = 4
j = 5
j = 6
breaked
i = 7
j = 1
j = 2
j = 3
j = 4
j = 5
j = 6
j = 7
breaked
i = 8
j = 1
j = 2
j = 3
j = 4
j = 5
j = 6
j = 7
j = 8
breaked
i = 9
j = 1
j = 2
j = 3
j = 4
j = 5
j = 6
j = 7
j = 8
j = 9
breaked
i = 10
j = 1
j = 2
j = 3
j = 4
j = 5
j = 6
j = 7
j = 8
j = 9
j = 10
breaked

上面的代码是两个for循环嵌套。因为break语句位于内层的for循环，因此，它会跳出内层for循环，但不会跳出外层for循环。

continue

break会跳出当前循环，也就是整个循环都不会执行了。而continue则是提前结束本次循环，直接继续执行下次循环。
举个栗子：

public class Main {public static void main(String[] args) {int sum = 0;for (int i=1; i<=10; i++) {System.out.println("begin i = " + i);if (i % 2 == 0) {continue; // continue语句会结束本次循环}sum = sum + i;System.out.println("end i = " + i);}System.out.println(sum); // 25}
}

结果：

begin i = 1
end i = 1
begin i = 2
begin i = 3
end i = 3
begin i = 4
begin i = 5
end i = 5
begin i = 6
begin i = 7
end i = 7
begin i = 8
begin i = 9
end i = 9
begin i = 10
25

注意：在多层嵌套的循环中，continue语句同样是结束本次自己所在的循环。

Xmind

最后，放上这一节的思维导图：

参考资料

流程控制 – 廖雪峰的官方网站

PS：如果觉得本篇本章对您有所帮助，欢迎关注、评论、赞！

Java学习笔记（三）：流程控制相关推荐

java学习笔记(三)：前端miniUI控件库入门
java学习笔记(三):前端miniUI控件库入门最近在一家公司实习学习,一上来就需要学习了解相关的前端内容--miniUI.而这个内容自己本身并没有了解学习过,上手也是遇到了不少的问题,于是想把自 ...
python学习笔记3—流程控制if、for、while
流程控制if if 语句 if expression: statement(s) else else语句: if 语句,else语句 if expression: statement(s) else: ...
Python学习笔记3 流程控制、迭代器、生成器
第3章流程控制.迭代器.生成器 3.1 选择语句 1.语法:(1)if -else (2)if-elif-else 2.注意:(1)每个条件后面要使用冒号:(2)使用缩进划分语句块(3)python ...
Python学习笔记02_流程控制
Python 文件的创建和执行创建和打开文件打开cmd,输入以下命令,运行.py 文件 python xxx.py 条件判断用代码告诉计算机,什么条件下该做什么.很多编程语言都会使用 if .e ...
java注解和反射——狂神说java学习笔记三
原文链接:公众号狂神说视频教程[狂神说B站]: https://www.bilibili.com/video/BV12J41137hu 如有侵权,联系立删什么是注解 Annotation是从JDK ...
【Java学习笔记三】抽象类与接口
对象的类型转换分为自动转换和强制转换两种派生类向基类转换是自动转换,因为派生类中包含基类基类向派生类的转换是强制转换强制类型转换是通过在转换对象前面使用圆括号运算符来实现,圆括号内为要转换的目标 ...
Java学习笔记三——数据类型
前言 Java是强类型(strongly typed)语言,强类型包含两方面的含义: 所有的变量必须先声明后使用: 指定类型的变量只能接受预支匹配的值. 这意味着每一个变量和表达式都有一个在编译时就确 ...
linux设置程序循环,linux shell编程学习笔记(7)流程控制之循环结构
2.1.for循环 1)遍历/列表式循环 --根据变量的不同取值,重复执行命令序列格式: for 变量名 in 值列表 do 命令序列 done 示例:输出在线的主机IP #!/bin/bash ...
JAVA学习笔记(三十一)-电影系统案例
伪代码系统的角色类准备用户购票用户评分商家功能首页设计先封装 public class Business extends User{// 店铺名称private String shopNa ...
JAVA学习笔记(三十九)-打印流
import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.PrintStream; i ...

Java学习笔记（三）：流程控制

目录

绪言