Java 入门之循环结构基础详细讲解

以下是按照Java最新技术趋势更新的循环结构实操内容，包含Stream API、并行处理、响应式编程等现代特性的应用示例。

现代Java中的循环技术进阶

Stream API：声明式集合处理

Java 8引入的Stream API彻底改变了集合处理方式，通过声明式编程替代传统循环，使代码更简洁、更易并行化。以下是Stream的典型应用场景：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        
        // 过滤长度大于4的名字并转为大写
        List<String> result = names.stream()
            .filter(name -> name.length() > 4)
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        
        // 输出：[ALICE, CHARLIE]
        System.out.println(result);
        
        // 并行处理：计算所有元素的平方和
        int sum = names.parallelStream()
            .mapToInt(name -> name.length() * name.length())
            .sum();
            
        System.out.println("平方和：" + sum);
    }
}

Stream与传统循环对比优势：

1. 代码更简洁，消除了样板代码
2. 支持惰性求值，提高性能
3. 轻松实现并行计算（parallelStream）
4. 链式调用增强可读性

响应式编程：异步非阻塞循环

在现代微服务和高并发场景中，响应式编程成为处理数据流的主流范式。以下是使用Project Reactor的简单示例：

import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;

public class ReactiveExample {
    public static void main(String[] args) {
        // 创建数据流
        Flux<Integer> numbers = Flux.range(1, 10)
            .publishOn(Schedulers.parallel()) // 指定执行线程池
            .map(i -> {
                System.out.println("处理数据: " + i + " on thread: " + Thread.currentThread().getName());
                return i * i;
            });
            
        // 订阅并消费数据
        numbers.subscribe(
            squared -> System.out.println("结果: " + squared),
            error -> error.printStackTrace(),
            () -> System.out.println("处理完成")
        );
        
        // 主线程等待，确保异步任务完成
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

响应式循环特点：

• 非阻塞式处理，提高资源利用率
• 背压机制防止数据过载
• 天然支持异步和并行
• 适用于I/O密集型场景

模式匹配与循环优化

Java 17引入的模式匹配（Pattern Matching）进一步简化了循环中的类型检查：

public class PatternMatchingExample {
    public static void main(String[] args) {
        List<Object> mixedList = Arrays.asList(10, "Hello", 3.14, true);
        
        for (Object obj : mixedList) {
            // 传统方式
            if (obj instanceof String) {
                String str = (String) obj;
                System.out.println("字符串长度: " + str.length());
            }
            
            // 模式匹配方式
            if (obj instanceof String str) {
                System.out.println("优化后字符串长度: " + str.length());
            }
        }
    }
}

实战案例：电商订单处理系统

以下是一个综合运用现代循环技术的电商订单处理示例：

import java.math.BigDecimal;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;

public class OrderProcessingSystem {
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    
    // 处理一批订单
    public List<Order> processOrders(List<Order> orders) {
        // 传统for循环
        for (Order order : orders) {
            validateOrder(order);
        }
        
        // Stream API处理
        return orders.stream()
            .parallel() // 并行处理
            .filter(this::validateOrder)
            .map(this::calculateDiscount)
            .map(this::applyTax)
            .collect(Collectors.toList());
    }
    
    // 异步处理订单
    public CompletableFuture<List<Order>> processOrdersAsync(List<Order> orders) {
        return CompletableFuture.supplyAsync(() -> 
            orders.stream()
                .map(order -> CompletableFuture.supplyAsync(() -> processSingleOrder(order), executor))
                .map(CompletableFuture::join)
                .collect(Collectors.toList()), 
            executor
        );
    }
    
    private Order processSingleOrder(Order order) {
        if (validateOrder(order)) {
            order = calculateDiscount(order);
            order = applyTax(order);
            sendConfirmationEmail(order);
        }
        return order;
    }
    
    // 业务方法省略实现
    private boolean validateOrder(Order order) { /* ... */ return true; }
    private Order calculateDiscount(Order order) { /* ... */ return order; }
    private Order applyTax(Order order) { /* ... */ return order; }
    private void sendConfirmationEmail(Order order) { /* ... */ }
}

record Order(String id, List<Item> items, BigDecimal total) {}
record Item(String name, BigDecimal price, int quantity) {}

性能优化与最佳实践

1. 优先使用Stream API：处理集合时，Stream通常比传统循环更高效且更易读

2. 合理选择并行处理：

   // 大集合并行处理
   largeList.parallelStream().forEach(this::processItem);
   
   // 小集合顺序处理
   smallList.stream().forEach(this::processItem);

3. 避免在循环中创建对象：

   // 低效
   for (int i = 0; i < 1000; i++) {
       StringBuilder sb = new StringBuilder(); // 每次循环创建新对象
       sb.append("Item: ").append(i);
   }
   
   // 高效
   StringBuilder sb = new StringBuilder();
   for (int i = 0; i < 1000; i++) {
       sb.setLength(0); // 重用对象
       sb.append("Item: ").append(i);
   }

4. 使用StringJoiner处理字符串拼接：

   import java.util.StringJoiner;
   
   StringJoiner joiner = new StringJoiner(", ");
   for (String name : names) {
       joiner.add(name);
   }
   String result = joiner.toString();

总结

从基础for循环到现代Stream API，Java的循环技术不断演进，为开发者提供了更高效、更优雅的方式处理重复任务。掌握这些循环结构的核心原理和适用场景，结合性能优化技巧，将帮助你编写出更具表现力、更高效的Java代码。在实际开发中，建议根据具体场景选择最合适的循环方式：简单遍历优先使用增强for，集合处理优先考虑Stream，异步场景使用响应式编程，让代码既简洁又强大。

---

Java 入门，循环结构，基础讲解，Java 循环，For 循环，While 循环，Do-While 循环，循环嵌套，Java 基础，编程入门，循环控制，Break 语句，Continue 语句，Java 教程，零基础学 Java

---

---

代码获取方式 pan.quark.cn/s/14fcf913b...

---