Java回归循环的使用方式

// 遍历数组
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// 嵌套示例：矩阵遍历
int[][] matrix = {{1, 2}, {3, 4}};
for (int row = 0; row < matrix.length; row++) {
    for (int col = 0; col < matrix[row].length; col++) {
        System.out.print(matrix[row][col] + " ");
    }
    System.out.println();
}

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
for (String name : names) {
    System.out.println(name);
}

// 嵌套示例：遍历对象图
class Department {
    List<Employee> employees;
}

for (Department dept : company.getDepartments()) {
    for (Employee emp : dept.getEmployees()) {
        System.out.println(emp.getName());
    }
}

// 文件读取示例
BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
String line;
while ((line = reader.readLine()) != null) {
    processLine(line);
}

// 嵌套示例：游戏主循环
while (gameRunning) {
    while (levelActive) {
        updateGameObjects();
    }
}

// 用户输入验证
Scanner scanner = new Scanner(System.in);
String input;
do {
    System.out.print("Enter 'yes' to continue: ");
    input = scanner.nextLine();
} while (!input.equalsIgnoreCase("yes"));

// 层级1：处理所有订单
for (Order order : orders) {
    
    // 层级2：处理订单中的商品
    for (OrderItem item : order.getItems()) {
        
        // 层级3：检查商品库存
        for (Warehouse warehouse : warehouses) {
            if (warehouse.hasStock(item)) {
                // 实际业务逻辑
            }
        }
    }
}

// 重构前
for (User user : users) {
    for (Post post : user.getPosts()) {
        for (Comment comment : post.getComments()) {
            processComment(comment);
        }
    }
}

// 重构后
for (User user : users) {
    processUserPosts(user);
}

private void processUserPosts(User user) {
    for (Post post : user.getPosts()) {
        processPostComments(post);
    }
}

private void processPostComments(Post post) {
    for (Comment comment : post.getComments()) {
        processComment(comment);
    }
}

for (Project project : projects) {
    List<Task> tasks = project.getTasks(); // 避免重复调用
    
    for (Task task : tasks) {
        List<Resource> resources = task.getResources(); // 临时变量
        
        for (Resource resource : resources) {
            // 业务逻辑
        }
    }
}

outerLoop: // 标签用于跳出多层循环
for (Customer customer : customers) {
    if (customer.isInactive()) continue; // 跳过非活跃客户
    
    for (Order order : customer.getOrders()) {
        if (order.isCancelled()) continue; // 跳过已取消订单
        
        for (OrderItem item : order.getItems()) {
            if (item.isDiscontinued()) {
                // 遇到停产商品，跳过当前客户所有处理
                continue outerLoop;
            }
            processItem(item);
        }
    }
}

// 优化前 - 每次内部循环都调用外部方法
for (Department dept : departments) {
    for (Employee emp : dept.getEmployees()) {
        if (emp.isEligibleForBonus()) {
            // ...
        }
    }
}

// 优化后 - 预先计算
Map<Department, List<Employee>> eligibleEmployees = new HashMap<>();
for (Department dept : departments) {
    List<Employee> eligible = dept.getEmployees().stream()
                                 .filter(Employee::isEligibleForBonus)
                                 .collect(Collectors.toList());
    eligibleEmployees.put(dept, eligible);
}

for (Department dept : departments) {
    for (Employee emp : eligibleEmployees.get(dept)) {
        // 直接处理符合条件的员工
    }
}

// 传统三层嵌套
for (Department dept : company.getDepartments()) {
    for (Employee emp : dept.getEmployees()) {
        for (Project project : emp.getProjects()) {
            if (project.isActive()) {
                System.out.println(project.getName());
            }
        }
    }
}

// Stream API 重构
company.getDepartments().stream()
    .flatMap(dept -> dept.getEmployees().stream())
    .flatMap(emp -> emp.getProjects().stream())
    .filter(Project::isActive)
    .forEach(project -> System.out.println(project.getName()));

for (int i = 0; i < regions.size(); i++) {
    Region region = regions.get(i);
    log.debug("Processing region [{}]/[{}]: {}", i+1, regions.size(), region.getName());
    
    for (int j = 0; j < region.getStores().size(); j++) {
        Store store = region.getStores().get(j);
        log.debug("  Processing store [{}]/[{}]: {}", j+1, region.getStores().size(), store.getId());
        
        for (int k = 0; k < store.getProducts().size(); k++) {
            Product product = store.getProducts().get(k);
            log.debug("    Processing product [{}]/[{}]: {}", k+1, store.getProducts().size(), product.getSKU());
        }
    }
}

// 打印对象摘要
System.out.println("Department structure:");
for (Department dept : company.getDepartments()) {
    System.out.println("├─ " + dept.getName() + 
                      " (" + dept.getEmployees().size() + " employees)");
    
    for (Employee emp : dept.getEmployees()) {
        System.out.println("│  ├─ " + emp.getName() + 
                          " (" + emp.getProjects().size() + " projects)");
    }
}

for (Warehouse warehouse : warehouses) {
    for (Product product : productsToCheck) {
        for (Shelf shelf : warehouse.getShelves()) {
            for (Bin bin : shelf.getBins()) {
                if (bin.contains(product) && bin.getQuantity() > 0) {
                    // 记录库存信息
                }
            }
        }
    }
}

// 预先建立产品到仓库位置的映射
Map<Product, List<Location>> productLocations = new HashMap<>();
for (Warehouse warehouse : warehouses) {
    for (Shelf shelf : warehouse.getShelves()) {
        for (Bin bin : shelf.getBins()) {
            Product product = bin.getProduct();
            if (product != null) {
                productLocations
                    .computeIfAbsent(product, k -> new ArrayList<>())
                    .add(new Location(warehouse, shelf, bin));
            }
        }
    }
}

// 直接查询映射
for (Product product : productsToCheck) {
    List<Location> locations = productLocations.get(product);
    if (locations != null) {
        for (Location loc : locations) {
            if (loc.getBin().getQuantity() > 0) {
                // 记录库存信息
            }
        }
    }
}