Java流程控制学习整理-CSDN博客

本文链接：https://blog.csdn.net/u012179475/article/details/132912926

Java流程控制

Scanner对象

java.util.Scanner 是Java中的一个类，用于从输入流中获取用户输入。它提供了一种方便的方式来读取各种类型的数据，例如整数、浮点数、字符串等，而不需要编写复杂的输入解析代码。通常Scanner对象用于与控制台或文件等输入源进行交互。

import java.util.Scanner; //导入Scanner类：首先，您需要导入`java.util.Scanner`类
/*
 *创建SCanner对象：使用`Scanner`构造函数创建一个`Scanner`对象，可以将输入源传递给构造函数。
 *通常，我们使用System.in表示从标准输入（键盘）获取输入。
 */
Scanner scanner = new Scanner(System.in); 
/*
 * nextInt() nextDouble() next() 等方法会阻塞程序的执行，等待用户输入数据
 */
scanner.hasNext();// 判断输入的内容是否为字符串
scanner.hasNextInt();//判断输入的内容是否为Int类型
scanner.hasNextDouble(); // 判断输入的内容是否为Double类型
int number = scanner.nextInt(); // 读取整数
double decimal = scanner.nextDouble();// 读取浮点数
String text = scanner.next(); //读取字符
String textLine = scanner.nextLine(); //读取一行字符串

scanner.close(); // 关闭Scanner对象：在使用完`Scanner`对象后，最好关闭它以释放资源。

示例：

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建Scanner对象
        if (scanner.hasNextInt()) { //判断键入的内容是否为Int
            System.out.println(scanner.nextInt());
        } else if (scanner.hasNextDouble()) { //判断键入的内容是否为Double
            System.out.println(scanner.nextDouble());
        }


    }
}

Java 顺序结构

Java 中的顺序结构是一种程序控制结构，它按照代码的书写顺序依次执行语句，没有分支或循环。顺序结构是程序的基本机构之一，它使程序能够按照线性顺序执行命令。以下是一些关于Java中顺序结构的要点：

**线性执行：**在顺序结构中，代码语句按照它们出现的顺序依次执行。从程序的起始点开始，按照代码的逐行顺序执行，直到到达程序的末尾。
**单一入口和单一出口：**顺序结构具有单一的入口和单一的出口点。程序从入口点开始执行，按顺序执行每个语句，最终到达出口点。
```
public class SequentiaExamle{
    public static void main(Sting[] args){
        System.out.println("这是第一条语句。")
        System.out.println("这是第二条语句。")
        System.out.println("这是第三条语句。")
    }
}
```
在上述实例中，三条System.out.println()语句按照顺序依次执行，每条语句在前一条执行完之后执行
**变量赋值和计算：**顺序结构也适用于变量的赋值和简单的数学计算。这些操作按照代码顺序依次执行。
```
int x = 5; //变量赋值
int y = 3;
int result = x + y; //计算
```
**方法调用：**当在方法中调用其他方法时，也遵循顺序结构。方法内部的语句按照它们的调用顺序执行。

顺序结构是编程的基础，它允许您编写直观的代码，按照自然的顺序执行操作。尽管它是最简单的控制结构之一，但它是构建更复杂算法和程序的基础。其他控制结构，如条件语句（if、switch）和循环语句（for、while）可以嵌套在顺序结构中，以创建更复杂的程序逻辑。

Java if 选择结构

在Java中，if语句是一种条件选择控制结构，用于根据某个条件的真假执行不同的代码块。

基础语法：

if (condition) {
    // 如果条件为真，执行这里的代码块
}

condition是一个布尔表达式，它可以是一个比较、逻辑表达式或任何返回布尔值的表达式。
如果condition为真（即true)，则执行if语句块内的代码；如果为假（即false)，则跳过if语句块。

**if-else语句：**用于在条件为真时执行一个代码块，在条件为假时执行另一个代码块。基本语法如下：

if (condition) {
    // 如果条件为真，执行这里的代码块
}else {
    // 如果条件为假，执行这里的代码块
}

**if-else if-else语句：**用于处理多个条件，依次检查每个条件并执行相应的代码块，基本语法如下：

if (condition1) {
    // 如果条件1为真，执行这里的代码块
}else if (condition2){
    // 如果条件2为真，执行这里的代码块
}else {
    // 如果以上条件都为假，执行这里的代码块
}

**嵌套的if语句：**可以在一个if语句块内含另一个if语句，以创建更复杂的条件逻辑。

int x = 10;
if (x > 5) {
    System.out.println("x 大于 5")
}
if (x < 20) {
    System.out.println("x 小于 20")
} else {
    System.out.println("x 不小于 20")
}
int y = 15;
if (y > 10) {
    System.out.println("y 大于10")
} else if (y ==10) {
    System.out.println("y 等于 10")
} else {
    System.out.println("y 小于 10")
}

if 语句是Java中用于实现条件逻辑的基本控制结构之一。根据条件的不同，您可以选择执行不同的代码块，从而使程序能够根据不同情况采取不同的行动。

Java switch 选择结构

Java中，switch语句是一种条件选择结构，用于根据表达式的值选择不同的代码块进行执行。

基础语法：

switch (expression) {
    case value1:
        // 如果expression 的值等于value1, 则执行这里的代码块
        break;
    case value2:
        // 如果expression 的值等于value2，则执行这里的代码块
        break;
    case value3:
        // 如果expression 的值等于value3，则执行这里的代码块
        break;
    default：
        // 如果expression 的值与任何case 都不匹配，则执行这里的代码块
        
}

expression 是一个表达式，其结果会被与case中的值进行比较，以确定要执行那个代码块。
case value1:和case value2:是可能的取值，他们用于比较expression的值。
break关键字用于表示一个case代码块的结束，如果匹配到一个case后，程序将跳出switch语句
default是可选的，它用于指定在没有匹配的情况下要执行的代码块

int day = 3;
switch (day) {
    case 1:
        System.out.println("星期一");
     case 2:
        System.out.println("星期二");   
     case 3:
        System.out.println("星期三");         
     case 4:
        System.out.println("星期四"); 
     case 5:
        System.out.println("星期五");
    default:
        System.out.println("周末");
}

在上述示例中，根据day的值，switch语句会执行不同的case代码块或者默认的default代码块

需要注意的是，switch语句的表达式必须是整数型（如int、char、byte等)或枚举类型。在Java SE7之后，还可以使用字符串作为swtich语句的表达式。

此外，switch语句可以用于处理多个分支情况，以便根据不同的值执行不同的代码块，比使用多个if-else if-else语句更具有可读性和效率。

Java while循环结构

while循环是Java中一种常见的循环结构，它用于根据某个条件重复执行一组语句，只要条件为真，循环就会继续执行。

while循环的基本语法

while (条件) {
    // 循环体内的代码
}

条件是一个布尔表达式，如果条件为真（true)，则执行循环体内的代码。如果条件为假（false），则跳出循环
循环体内的代码是需要重复执行的代码块

int sum = 0; // 初始化一个变量来存储和
int currentNumber = 1; // 初始化一个变量，表示当前整数
while (currentNumber <= 5) {
    sum += currentNumber; // 将当前整数加到和中
    currentNumber++;
}
System.out.println("1 到 5的整数之和是：" + sum);

在此示例中，while循环首先检查currentNumber <= 5是否为真，如果为真，则执行循环体内的代码块，然后增加currentNumber的值，继续下一次迭代，直到currentNumber大于5为止。在每次迭代中，我们将currentNumber的值添加到sum中，以计算整数之和。

需要主要的是，如果条件始终为真或者没有适当的退出条件，while循环可能会变成无限循环，导致程序无法结束。因此，确保在编写while循环时设置正确的退出条件非常重要。

另外，有时候可能需要在while循环之前初始化循环变量，以及在循环体内更新循环变量的值，这取决于具体的循环需求。

Java do-while 循环结构

do-while循环是Java中的一种循环结构，它与while循环类似，但有一个关键区别：do-while循环会先执行一次循环体，然后再检查循环条件。这意味着do-while循环至少会执行一次循环体，即使条件一开始就问假。

do-while循环的基本语法如下：

do {
    // 循环体内的代码
} while(条件);

条件是一个布尔表达式，它在每次迭代之后被检查。如果条件为真（true），则继续执行循环体内的代码块，否则跳出循环。

import java.util.Scanner;

public class GuessNumber {
    public static void main(String [] args) {
        Scanner scanner = new Scanner(System.in);
        int targetNumber = 42; //要猜测的目标数字
        int guess;
        do {
            System.out.print("请输入猜测的数字："）
            guess = scanner.nextInt();
            if (guess < targetNumber) {
                System.out.println("太小了，请再试一次");
            }else if (guess > targetNumber){
                System.out.println("太大了，请再试一次");
            }else {
                System.out.println("恭喜你，猜对了！")
            }
        } while (guess != targetNumber);
         
         sacnner.close();
    }                            
}

在此示例中，玩家将反复输入猜测的数字，直到猜中目标数字为止。即使玩家第一次猜测错误，由于是do-while循环，程序会至少执行一次，然后检查条件。

do-while循环通常在需要确保至少执行一次循环体的情况下使用，例如进行用户输入验证或菜单选择等。与while循环相比，它的循环体至少会执行一次。

Java for 循环结构

Java中，for循环是一种常见的循环结构，用于执行已知次数的迭代或遍历数组、集合等数据结构。

for循环的基础语法如下：

for (初始化; 条件; 更新) {
    // 循环体内的代码
}

初始化：在循环开始前执行一次，通常用于初始化循环变量。
条件：在每次迭代之前检查的条件，如果条件为真（true），则继续执行循环体，否则退出循环。
更新：在每次迭代之后执行，通常用于更新循环变量的值。
循环体内的代码是需要重复执行的代码块。

**遍历数组：**使用for循环遍历数组中的元素。

int [] numbers = {1,2,3,4,5};
for (int i =0; i < numbers.length; i++) {
    System.out.println("元素值：" + numbers[i]);
}

**计算累加和：**使用for循环计算一系列整数的累加和。

int sum = 0;
for (int i = i; i <= 10; i++) {
    sum += i;
}
System.out.println("1 到 10 的整数之和是：" + sum);

**迭代字符串：**使用for 循环迭代字符串中的字符。

String text = "Hello";
for (int i =0; i < text.length(); i++) {
    char c = text.charAt(i);
    System.out.println("字符：" + c);
}

**嵌套的for循环：**可以在一个for循环内嵌套另一个for循环，用于处理多维数组或生成矩阵等。

for (int i= 1; i <= 3; i++) {
    for (int j =1;j <=3; j++)
        System.out.println("i=" + i + ", j=" + j);
}

for 循环是编程中最常用的循环结结构之一，他具有灵活性可可读性，适用于各种迭代和循环需求。可以根据具体的情况设置不同的初始化、条件和更新来控制循环的行为。

Java 增强for循环结构

Java中的增强for循环（也称为for-each循环）是一种用于遍历数组、集合和其他可迭代对象的简化循环结构。它可以更轻松地遍历这些数据结构，而无需手动管理索引或迭代器。

增强for循环的语法

for (元素类型 元素变量 : 可迭代对象) {
    // 循环体内的代码，使用元素变量访问当前元素
}

元素类型：是集合或数组中元素的数类型
元素变量：是一个新的变量，它会依次代表可迭代对象中的每个元素。
可迭代对象：是要遍历的集合、数组或其他实现了Iterable接口的对象。

遍历数组：

int [] numbers = {1,2,3,4,5};
for (int number : numbers) {
    System.out.println("元素值：" + number);
}

遍历集合：

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

for (String name : names) {
    System.out.println("姓名：" + name)
}

遍历字符串：

String text = "hello";
for (char c : text.toCharArray()) {
    System.out.println("字符：" + c)
}

遍历集合中的自定义对象：

class Person {
	private String name;
	
	public Person(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}

List<Person> people = new ArrayList<>();
people.add(new Person("Alice"));
people.add(new Person("Bob"));

for (Person person :people) {
	System.out.println("姓名：" + person.getName());
}

增强 for 循环使代码更加简洁和易读，适用于大多数集合和数组的遍历操作。需要主要的是，增强for循环无法用于需要修改集合或数组中元素的情况，因为它只提供了对元素的只读访问。如果需要修改集合中的元素，仍然需要使用传统的for循环结构。

Java break与continue

break: 用于立即跳出循环，不在执行循环体内的任何代码，即使循环条件仍然为真。break通常用于中断循环，以满足某个条件或退出循环。
```
for (int i =1; i <=5; i++) {
    if (i ==3) {
        break; //当 i 等于3 时跳出循环
    }
    System.out.println("i 的值是：" + i)
}
```
上述代码中，当i等于3时，break语句被执行，导致跳出循环，不再打印后续的值。
continue：用于跳过当前循环迭代中剩余的代码，并继续下一次循环迭代。它通常用于在某些条件下跳过当前迭代，但继续执行后续迭代。
```
for (int i = 1; i <=5; i++) {
    if (i ==3) {
        continue; // 当 i 等于 3 时 跳过当前迭代
    }
    System.out.println("i 的值是：" + i);
}
```
上述代码中，当i等于3时，continue语句被执行，导致跳过打印语句，但继续下一次循环迭代。