1. 循环结构

概念：通过某个条件，重复的执行一段逻辑代码
循环由四部分组成：初始部分、循环条件、循环操作、迭代部分

while 循环
do while 循环
for 循环
嵌套循环

1.1 循环体

for(初始语句；循环体条件表达式；循环体后语句) { 循环体}
while(条件表达式) {循环体}
do-while语句，至少执行一次 do {循环体} while(条件表达式); 注意结尾的冒号
死循环/无限循环（endless loop / infinite loop）, 要充分考虑边界情况

for (int i = 1; i < 10; i++) {
    String value = "";
    for (int j = 1; j < 10; j++) {
        if (j > i) {
            break;
        }
        value += i + "*" + j + "="  + i * j + "\t";
    }
    System.out.println(value);
}

1.2 流程控制语句

break: 跳出 switch，终止循环结构（Break outside switch or loop）
continue: 结束本次，进入下一次循环

for (int i = 0; i < 10; i++) {
    switch (i) {
        case 5:
            System.out.println("case 5");
            continue;
        default:
            // System.out.println(i);
    }
    System.out.println("switch end: " + i);
}

补充
break 在循环和switch语句中使用，用于终止最近的封闭代码块，如果在嵌套循环中，则只终止最近的循环。
continue 在循环中使用，不能单独在switch中使用，可以在循环内的switch中使用，用于跳过当次循环，直接进入下一次循环

2. while 循环

特点：首次即有入口条件，先判断、再执行，适用于循环次数明确的情况

while(布尔表达式) {
  // do something
}

public void test() {
    int i = 0;           // 1. 初始部分
    while (i < 100) {    // 2. 循环条件
        // do something  // 3. 循环操作
        i++;             // 4. 迭代部分：控制循环条件改变的增量
    }
}

2.1 do-while 循环

特点：首次没有入口条件，先执行、再判断，适用于循环次数不明确的情况
流程：先执行一次循环操作后，再进行布尔表达式的判断；如果结果为 true, 则再次执行循环操作

do {
  // do something
} while (布尔表达式);

3. for 循环

语法 for(初始化 ; 布尔表达式 ; 迭代部分) { // 逻辑代码 }
特点：首次即有入口条件，先判断、再执行，适用于循环次数明确的情况

执行流程：

首次执行初始部分（仅执行一次）
判断布尔表达式，若结果为 true, 执行逻辑代码
逻辑代码执行完后，执行迭代部分，再次执行步骤2

int i = 0;
for ( ; i < 100; ) {
    // do something
    i++;
}
// 等价
for (int i = 0; i < 100; i++) {
    // do something
}

嵌套循环

// 外层控制行数，内层控制列数
for (int i = 0; i < 9; i++) {
    for (int j = 0; j <= i; j++) {
        System.out.print("*");
    }
    System.out.println();
}

3.1 增强for循环

在循环中没有当前的索引，无法对指定元素进行操作

List<String> list = Arrays.asList("aaa", "bbb");
for (String s : list) {
    
}

3.2 forEach 循环

forEach 里的 return 只能结束本次循环，无法终止

@Test
public void testForeach() {
    OrderDTO orderDTO = new OrderDTO();
    orderDTO.setOrderItemList(
            Arrays.asList(new OrderItemDTO(1001L, "A001"), new OrderItemDTO(1002L, "A002"),
                    new OrderItemDTO(1003L, "A003"), new OrderItemDTO(1004L, "A004")));

    Optional.ofNullable(orderDTO.getOrderItemList())
            .orElse(new ArrayList<>())
            .forEach(orderItemDTO -> {
                if (orderItemDTO.getId() == 1003L) {
                    // 小知识：foreach()不可以用break,continue来中止的操作
                    // 此处的 return 类似于 continue
                    return;
                }
                System.out.println(orderItemDTO.getId());
            });
}

改为 filter() 形式更简洁

Optional.ofNullable(orderDTO.getOrderItemList())
        .orElse(new ArrayList<>())
        .stream()
        .filter(orderItemDTO -> orderItemDTO.getId() != 1003L)
        .forEach(orderItemDTO -> {
            System.out.println(orderItemDTO.getId());
        });

若需跳出 forEach

Optional.ofNullable(orderDTO.getOrderItemList())
        .orElse(new ArrayList<>())
        .stream()
        .anyMatch(orderItemDTO -> {
            if (orderItemDTO.getId() == 1003L) {
                return true;
            }
            System.out.println(orderItemDTO.getId());
            return false;
        });