1. 集合遍历方式概述

1.1 常见遍历方式

Java集合提供了多种遍历方式，每种方式在不同场景下的性能表现各不相同。

public class TraversalMethodsOverview {
    
    public void demonstrateTraversalMethods() {
        List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
        
        // 1. 传统for循环（索引访问）
        for (int i = 0; i < list.size(); i++) {
            String item = list.get(i);
            System.out.println(item);
        }
        
        // 2. 增强for循环（for-each）
        for (String item : list) {
            System.out.println(item);
        }
        
        // 3. 迭代器遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);
        }
        
        // 4. Stream遍历
        list.stream().forEach(System.out::println);
        
        // 5. 并行Stream遍历
        list.parallelStream().forEach(System.out::println);
    }
}

1.2 遍历方式分类

2. ArrayList遍历性能分析

2.1 ArrayList各种遍历方式性能测试

public class ArrayListTraversalPerformance {
    
    private static final int SIZE = 1000000;
    
    public void testAllTraversalMethods() {
        ArrayList<Integer> list = new ArrayList<>();
        
        // 准备数据
        for (int i = 0; i < SIZE; i++) {
            list.add(i);
        }
        
        System.out.println("=== ArrayList遍历性能测试 ===");
        
        testIndexedForLoop(list);
        testEnhancedForLoop(list);
        testIterator(list);
        testStreamForEach(list);
        testParallelStream(list);
    }
    
    // 1. 索引for循环 - 最快
    private void testIndexedForLoop(ArrayList<Integer> list) {
        long startTime = System.nanoTime();
        
        for (int i = 0; i < list.size(); i++) {
            Integer value = list.get(i); // O(1)随机访问
            // 模拟处理
        }
        
        long endTime = System.nanoTime();
        System.out.println("索引for循环: " + (endTime - startTime) / 1000000 + "ms");
    }
    
    // 2. 增强for循环 - 推荐
    private void testEnhancedForLoop(ArrayList<Integer> list) {
        long startTime = System.nanoTime();
        
        for (Integer value : list) {
            // 模拟处理
        }
        
        long endTime = System.nanoTime();
        System.out.println("增强for循环: " + (endTime - startTime) / 1000000 + "ms");
    }
    
    // 3. Iterator遍历
    private void testIterator(ArrayList<Integer> list) {
        long startTime = System.nanoTime();
        
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer value = iterator.next();
            // 模拟处理
        }
        
        long endTime = System.nanoTime();
        System.out.println("Iterator遍历: " + (endTime - startTime) / 1000000 + "ms");
    }
    
    // 4. Stream forEach
    private void testStreamForEach(ArrayList<Integer> list) {
        long startTime = System.nanoTime();
        
        list.stream().forEach(value -> {
            // 模拟处理
        });
        
        long endTime = System.nanoTime();
        System.out.println("Stream forEach: " + (endTime - startTime) / 1000000 + "ms");
    }
    
    // 5. 并行Stream
    private void testParallelStream(ArrayList<Integer> list) {
        long startTime = System.nanoTime();
        
        list.parallelStream().forEach(value -> {
            // 模拟处理
        });
        
        long endTime = System.nanoTime();
        System.out.println("并行Stream: " + (endTime - startTime) / 1000000 + "ms");
    }
}

2.2 ArrayList遍历性能优化

public class ArrayListTraversalOptimization {
    
    // 优化1: 缓存size()避免重复调用
    public void optimizedIndexedLoop(ArrayList<Integer> list) {
        int size = list.size(); // 缓存size
        
        for (int i = 0; i < size; i++) {
            Integer value = list.get(i);
            // 处理逻辑
        }
    }
    
    // 优化2: 使用局部变量减少方法调用
    public void optimizedIteratorLoop(ArrayList<Integer> list) {
        for (Iterator<Integer> it = list.iterator(); it.hasNext(); ) {
            Integer value = it.next();
            // 处理逻辑
        }
    }
    
    // 优化3: 批量处理减少函数调用开销
    public void batchProcessing(ArrayList<Integer> list) {
        final int BATCH_SIZE = 1000;
        
        for (int i = 0; i < list.size(); i += BATCH_SIZE) {
            int end = Math.min(i + BATCH_SIZE, list.size());
            
            // 批量处理
            for (int j = i; j < end; j++) {
                Integer value = list.get(j);
                // 处理逻辑
            }
        }
    }
}

3. LinkedList遍历性能分析

3.1 LinkedList遍历方式对比

public class LinkedListTraversalPerformance {
    
    private static final int SIZE = 100000; // LinkedList较小的测试规模
    
    public void testLinkedListTraversal() {
        LinkedList<Integer> list = new LinkedList<>();
        
        // 准备数据
        for (int i = 0; i < SIZE; i++) {
            list.add(i);
        }
        
        System.out.println("=== LinkedList遍历性能测试 ===");
        
        testIndexedForLoop(list);
        testEnhancedForLoop(list);
        testIterator(list);
    }
    
    // 1. 索引for循环（性能极差）
    private void testIndexedForLoop(LinkedList<Integer> list) {
        long startTime = System.nanoTime();
        
        for (int i = 0; i < list.size(); i++) {
            Integer value = list.get(i); // O(n)操作！总复杂度O(n²)
            // 模拟处理
        }
        
        long endTime = System.nanoTime();
        System.out.println("索引for循环: " + (endTime - startTime) / 1000000 + "ms");
    }
    
    // 2. 增强for循环（推荐）
    private void testEnhancedForLoop(LinkedList<Integer> list) {
        long startTime = System.nanoTime();
        
        for (Integer value : list) {
            // 模拟处理
        }
        
        long endTime = System.nanoTime();
        System.out.println("增强for循环: " + (endTime - startTime) / 1000000 + "ms");
    }
    
    // 3. Iterator遍历（推荐）
    private void testIterator(LinkedList<Integer> list) {
        long startTime = System.nanoTime();
        
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer value = iterator.next();
            // 模拟处理
        }
        
        long endTime = System.nanoTime();
        System.out.println("Iterator遍历: " + (endTime - startTime) / 1000000 + "ms");
    }
}

4. Has