Java枚举遍历案例怎么编写

本文目录导读：

1. 基础枚举定义
2. 多种遍历方式
3. 复杂枚举遍历案例
4. 实际应用案例
5. 性能优化遍历

我来为你详细介绍Java枚举遍历的多种方式及案例：

基础枚举定义

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

多种遍历方式

使用 values() 方法（最常用）

public class EnumTraversalExample {
    public static void main(String[] args) {
        System.out.println("=== 使用 values() 方法 ===");
        for (Day day : Day.values()) {
            System.out.println("今天是" + day);
        }
    }
}

使用 EnumSet（推荐）

import java.util.EnumSet;
public class EnumSetTraversal {
    public static void main(String[] args) {
        System.out.println("=== 使用 EnumSet ===");
        EnumSet<Day> days = EnumSet.allOf(Day.class);
        for (Day day : days) {
            System.out.println("星期" + day.ordinal() + ": " + day);
        }
    }
}

使用 forEach + Lambda（Java 8+）

import java.util.Arrays;
public class LambdaTraversal {
    public static void main(String[] args) {
        System.out.println("=== 使用 Lambda 表达式 ===");
        Arrays.stream(Day.values()).forEach(day -> {
            System.out.println(day.name() + " (索引: " + day.ordinal() + ")");
        });
        // 更简洁的写法
        Arrays.asList(Day.values()).forEach(System.out::println);
    }
}

使用 Iterator

import java.util.Arrays;
import java.util.Iterator;
public class IteratorTraversal {
    public static void main(String[] args) {
        System.out.println("=== 使用迭代器 ===");
        Iterator<Day> iterator = Arrays.asList(Day.values()).iterator();
        while (iterator.hasNext()) {
            System.out.println("当前元素: " + iterator.next());
        }
    }
}

复杂枚举遍历案例

带属性和方法的枚举

public enum Status {
    PENDING("待处理", 0),
    PROCESSING("处理中", 1),
    COMPLETED("已完成", 2),
    CANCELLED("已取消", -1);
    private String description;
    private int code;
    private Status(String description, int code) {
        this.description = description;
        this.code = code;
    }
    public String getDescription() {
        return description;
    }
    public int getCode() {
        return code;
    }
}

遍历带有属性的枚举

public class ComplexEnumTraversal {
    public static void main(String[] args) {
        System.out.println("=== 遍历带有属性的枚举 ===");
        // 方式1：普通遍历
        for (Status status : Status.values()) {
            System.out.printf("状态: %s, 描述: %s, 编码: %d%n", 
                status, status.getDescription(), status.getCode());
        }
        // 方式2：流式处理
        System.out.println("\n=== 流式处理带条件的遍历 ===");
        Arrays.stream(Status.values())
            .filter(s -> s.getCode() >= 0)
            .forEach(s -> System.out.println(s.getDescription() + " [有效状态]"));
    }
}

实际应用案例

订单状态管理

public enum OrderStatus {
    NEW("新订单", "#FF0000"),
    PAID("已支付", "#00FF00"),
    SHIPPED("已发货", "#0000FF"),
    DELIVERED("已送达", "#FF00FF"),
    COMPLETED("已完成", "#808080"),
    CANCELLED("已取消", "#000000");
    private String displayName;
    private String color;
    OrderStatus(String displayName, String color) {
        this.displayName = displayName;
        this.color = color;
    }
    public String getDisplayName() { return displayName; }
    public String getColor() { return color; }
    // 根据代码查找枚举
    public static OrderStatus fromString(String text) {
        for (OrderStatus status : OrderStatus.values()) {
            if (status.name().equalsIgnoreCase(text)) {
                return status;
            }
        }
        return null;
    }
}
// 使用示例
public class OrderSystem {
    public static void main(String[] args) {
        System.out.println("=== 订单状态管理系统 ===");
        // 显示所有状态
        System.out.println("可用的订单状态:");
        for (OrderStatus status : OrderStatus.values()) {
            System.out.printf("  %-10s: %s (颜色: %s)%n", 
                status, status.getDisplayName(), status.getColor());
        }
        // 查找特定状态
        String searchStatus = "PAID";
        OrderStatus found = OrderStatus.fromString(searchStatus);
        System.out.println("\n查找状态 '" + searchStatus + "': " + 
            (found != null ? found.getDisplayName() : "未找到"));
        // 批量处理
        System.out.println("\n待处理订单状态:");
        Arrays.stream(OrderStatus.values())
            .filter(s -> s.ordinal() < OrderStatus.DELIVERED.ordinal())
            .forEach(s -> System.out.println("  - " + s.getDisplayName()));
    }
}

性能优化遍历

public class OptimizedTraversal {
    // 缓存枚举值数组，避免重复调用 values()
    private static final Day[] DAYS = Day.values();
    private static final List<Day> DAY_LIST = Arrays.asList(Day.values());
    public static void main(String[] args) {
        // 避免频繁调用 values()
        for (Day day : DAYS) {
            processDay(day);
        }
        // 使用 List 接口
        for (Day day : DAY_LIST) {
            if (day == Day.SATURDAY || day == Day.SUNDAY) {
                System.out.println(day + " 是周末");
            }
        }
    }
    private static void processDay(Day day) {
        System.out.println("处理: " + day);
    }
}

枚举遍历的核心方法：

• values()：最基础的方法
• EnumSet：对枚举集合操作更高效
• Stream API：适合复杂数据处理
• Iterator：传统迭代方式

选择建议：

• 简单遍历：使用 for-each + values()
• 需要集合操作：使用 EnumSet
• 需要复杂过滤或转换：使用 Stream API
• 需要修改集合：使用 Iterator