for 关键字

概述

for 关键字用于创建循环结构，可以重复执行代码块。Java提供了传统for循环和增强for循环（for-each）两种形式。

语法格式

传统for循环

for (初始化; 条件判断; 更新表达式) {
    // 循环体
}

增强for循环（for-each）

for (元素类型 变量名 : 集合或数组) {
    // 循环体
}

基本用法

传统for循环

public class BasicForLoop {
    public static void main(String[] args) {
        // 基本计数循环
        System.out.println("=== 基本计数循环 ===");
        for (int i = 0; i < 5; i++) {
            System.out.println("第" + (i + 1) + "次循环，i = " + i);
        }

        // 倒序循环
        System.out.println("\n=== 倒序循环 ===");
        for (int i = 10; i > 0; i--) {
            System.out.println("倒计时：" + i);
        }

        // 步长为2的循环
        System.out.println("\n=== 步长为2的循环 ===");
        for (int i = 0; i <= 20; i += 2) {
            System.out.println("偶数：" + i);
        }

        // 多个初始化变量
        System.out.println("\n=== 多变量循环 ===");
        for (int i = 0, j = 10; i < j; i++, j--) {
            System.out.println("i = " + i + ", j = " + j);
        }
    }
}

增强for循环

import java.util.*;

public class EnhancedForLoop {
    public static void main(String[] args) {
        // 遍历数组
        System.out.println("=== 遍历数组 ===");
        int[] numbers = {1, 2, 3, 4, 5};
        for (int num : numbers) {
            System.out.println("数字：" + num);
        }

        // 遍历字符串数组
        System.out.println("\n=== 遍历字符串数组 ===");
        String[] names = {"张三", "李四", "王五"};
        for (String name : names) {
            System.out.println("姓名：" + name);
        }

        // 遍历List集合
        System.out.println("\n=== 遍历List集合 ===");
        List<String> fruits = Arrays.asList("苹果", "香蕉", "橙子");
        for (String fruit : fruits) {
            System.out.println("水果：" + fruit);
        }

        // 遍历Set集合
        System.out.println("\n=== 遍历Set集合 ===");
        Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
        for (Integer value : set) {
            System.out.println("集合元素：" + value);
        }
    }
}

嵌套for循环

public class NestedForLoop {
    public static void main(String[] args) {
        // 打印乘法表
        System.out.println("=== 九九乘法表 ===");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "×" + i + "=" + (i * j) + "\t");
            }
            System.out.println();
        }

        // 打印星号图案
        System.out.println("\n=== 星号三角形 ===");
        for (int i = 1; i <= 5; i++) {
            // 打印空格
            for (int j = 5; j > i; j--) {
                System.out.print(" ");
            }
            // 打印星号
            for (int k = 1; k <= i; k++) {
                System.out.print("* ");
            }
            System.out.println();
        }

        // 二维数组遍历
        System.out.println("\n=== 二维数组遍历 ===");
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

实际应用示例

import java.util.*;

public class ForLoopApplications {

    // 查找数组中的最大值
    public static int findMax(int[] array) {
        if (array.length == 0) {
            throw new IllegalArgumentException("数组不能为空");
        }

        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }

    // 计算数组平均值
    public static double calculateAverage(double[] scores) {
        double sum = 0;
        for (double score : scores) {
            sum += score;
        }
        return sum / scores.length;
    }

    // 统计字符串中各字符出现次数
    public static Map<Character, Integer> countCharacters(String text) {
        Map<Character, Integer> charCount = new HashMap<>();

        for (int i = 0; i < text.length(); i++) {
            char ch = text.charAt(i);
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }

        return charCount;
    }

    // 生成斐波那契数列
    public static List<Integer> generateFibonacci(int n) {
        List<Integer> fibonacci = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            if (i <= 1) {
                fibonacci.add(i);
            } else {
                int next = fibonacci.get(i - 1) + fibonacci.get(i - 2);
                fibonacci.add(next);
            }
        }

        return fibonacci;
    }

    // 矩阵转置
    public static int[][] transpose(int[][] matrix) {
        int rows = matrix.length;
        int cols = matrix[0].length;
        int[][] transposed = new int[cols][rows];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                transposed[j][i] = matrix[i][j];
            }
        }

        return transposed;
    }

    public static void main(String[] args) {
        // 测试查找最大值
        int[] numbers = {3, 7, 2, 9, 1, 5};
        System.out.println("最大值：" + findMax(numbers));

        // 测试计算平均值
        double[] scores = {85.5, 92.0, 78.5, 88.0, 95.5};
        System.out.println("平均分：" + calculateAverage(scores));

        // 测试字符统计
        String text = "hello world";
        Map<Character, Integer> charCount = countCharacters(text);
        System.out.println("字符统计：" + charCount);

        // 测试斐波那契数列
        List<Integer> fibonacci = generateFibonacci(10);
        System.out.println("斐波那契数列：" + fibonacci);

        // 测试矩阵转置
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
        int[][] transposed = transpose(matrix);
        System.out.println("原矩阵：");
        printMatrix(matrix);
        System.out.println("转置矩阵：");
        printMatrix(transposed);
    }

    private static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int element : row) {
                System.out.print(element + " ");
            }
            System.out.println();
        }
    }
}

循环控制语句

public class LoopControl {
    public static void main(String[] args) {
        // 使用break跳出循环
        System.out.println("=== 使用break ===");
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                System.out.println("遇到5，跳出循环");
                break;
            }
            System.out.println("i = " + i);
        }

        // 使用continue跳过当前迭代
        System.out.println("\n=== 使用continue ===");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            System.out.println("奇数：" + i);
        }

        // 标签break（跳出多层循环）
        System.out.println("\n=== 标签break ===");
        outer: for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    System.out.println("在(" + i + "," + j + ")处跳出外层循环");
                    break outer;
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }

        // 标签continue（继续外层循环）
        System.out.println("\n=== 标签continue ===");
        outer: for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (j == 2) {
                    System.out.println("跳过i=" + i + "的剩余内层循环");
                    continue outer;
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
    }
}

无限循环和特殊用法

public class SpecialForLoops {
    public static void main(String[] args) {
        // 省略初始化
        int i = 0;
        for (; i < 5; i++) {
            System.out.println("省略初始化：i = " + i);
        }

        // 省略更新表达式
        System.out.println("\n=== 省略更新表达式 ===");
        for (int j = 0; j < 5;) {
            System.out.println("手动更新：j = " + j);
            j++; // 手动更新
        }

        // 省略条件判断（无限循环，需要break跳出）
        System.out.println("\n=== 无限循环示例 ===");
        int count = 0;
        for (;;) {
            System.out.println("无限循环：" + count);
            count++;
            if (count >= 3) {
                break;
            }
        }

        // 空循环体
        System.out.println("\n=== 空循环体示例 ===");
        int sum = 0;
        for (int k = 1; k <= 5; sum += k, k++) {
            // 空循环体，所有操作在循环表达式中完成
        }
        System.out.println("求和结果：" + sum);
    }
}

性能和最佳实践

1. 循环优化

import java.util.*;

public class LoopOptimization {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c", "d", "e");

        // 避免在循环中重复计算
        // 不好的做法
        for (int i = 0; i < list.size(); i++) { // 每次都调用size()
            System.out.println(list.get(i));
        }

        // 好的做法
        int size = list.size(); // 只计算一次
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }

        // 对于ArrayList，使用增强for循环更简洁
        for (String item : list) {
            System.out.println(item);
        }
    }
}

2. 选择合适的循环类型

import java.util.*;

public class LoopSelection {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        // 需要索引时使用传统for循环
        System.out.println("=== 需要索引 ===");
        for (int i = 0; i < array.length; i++) {
            System.out.println("索引" + i + "：" + array[i]);
        }

        // 只遍历元素时使用增强for循环
        System.out.println("\n=== 只遍历元素 ===");
        for (int value : array) {
            System.out.println("值：" + value);
        }

        // 需要修改集合时避免使用增强for循环
        System.out.println("\n=== 修改集合 ===");
        List<Integer> modifiableList = new ArrayList<>(list);

        // 错误做法（可能抛出ConcurrentModificationException）
        /*
        for (Integer item : modifiableList) {
            if (item % 2 == 0) {
                modifiableList.remove(item); // 危险操作
            }
        }
        */

        // 正确做法
        for (int i = modifiableList.size() - 1; i >= 0; i--) {
            if (modifiableList.get(i) % 2 == 0) {
                modifiableList.remove(i);
            }
        }
        System.out.println("删除偶数后：" + modifiableList);
    }
}

常见错误和注意事项

1. 数组越界

public class ArrayBounds {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};

        // 错误：可能导致数组越界
        /*
        for (int i = 0; i <= array.length; i++) { // 注意：应该是 < 而不是 <=
            System.out.println(array[i]);
        }
        */

        // 正确做法
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

2. 修改循环变量

public class LoopVariableModification {
    public static void main(String[] args) {
        // 小心在循环体内修改循环变量
        System.out.println("=== 修改循环变量示例 ===");
        for (int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
            if (i == 5) {
                i += 2; // 修改循环变量，下次循环i会是8
            }
        }
    }
}

3. 增强for循环的限制

import java.util.*;

public class EnhancedForLimitations {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};

        // 增强for循环不能修改数组元素
        for (int value : array) {
            value = value * 2; // 这不会改变原数组
        }
        System.out.println("原数组未改变：" + Arrays.toString(array));

        // 需要修改时使用传统for循环
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
        System.out.println("修改后的数组：" + Arrays.toString(array));
    }
}

for循环是Java中最常用的控制结构之一，掌握其各种用法和最佳实践对编写高效的代码非常重要。