浅聊java中的枚举以及关于枚举的常见面试问题

关注

原创最新推荐文章于 2026-07-23 08:30:00 发布 1.4k 阅读 AI 写同款· GEO 优化 ›

Java基础之Java枚举絮叨昨天刚好有遇到一个枚举的小问题，然后发现自己并不是那么熟悉它，然后在开发中，枚举用的特别多，所以有了今天的文章。什么是枚举 Java中的枚举是一种类型，顾名思义：就是一个一个列举出来。所以它一般都是表示一个有限的集合类型，它是一种类型，在维基百科中给出的定义是：在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。这两种类型经常（但不总是）重叠.。枚举是一个被命名的整型常数的集合，枚举在日常生活中很常见，例如表示星期的SUNDAY、MO 阅读详情

基本概念：

什么是枚举？

枚举（Enum）是一种特殊的类，它用于表示一组固定的常量。枚举从Java 5（也称为Java 1.5）开始引入，提供了一种比传统常量（如使用public static final定义的变量）更类型安全、更易读和更易维护的方式来定义一组常量。

如何定义枚举？

枚举是通过关键字enum来定义的。枚举的每一个实例都是该枚举类型的一个对象，这些对象在编译时就已经被创建，并且不能被实例化。枚举类默认继承自java.lang.Enum类，但不能显式继承其他类（也不能被继承，因为当枚举被编译为类时会被final修饰，但它可以实现接口）。

public enum Color {  
    RED, GREEN, BLUE;  
}

枚举的特性有哪些？

类型安全：枚举提供了一种类型安全的方式来表示一组常量，避免了使用整数或字符串表示常量时可能发生的错误。
自动序列化：枚举实现了java.io.Serializable接口，因此它们可以自动序列化。
单例实现：枚举是实现单例模式的最佳方式之一，因为它保证了线程安全和实例的唯一性。
包含方法和属性：枚举可以包含构造方法（必须是私有的）、字段、方法和抽象方法。

枚举的常用方法有哪些？

values()：返回包含枚举中所有元素的数组。
valueOf(String name)：根据枚举常量的名称返回对应的枚举常量。
ordinal()：返回枚举常量在枚举声明中的位置（从0开始）。
compareTo(E o)：在枚举类型上实现自然排序。这个方法允许枚举常量按照它们在枚举声明中出现的顺序进行比较。
name()：返回枚举常量的名称，这个名称就是声明枚举常量时所用的标识符。
toString()：默认情况下，枚举的toString()方法返回枚举常量的名称。但你也可以重写这个方法以返回更有意义的字符串表示。

枚举的日常使用示例：

定义

枚举类是通过enum关键字来定义的。枚举类的声明类似于类，但关键字是enum而不是class。

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

使用

你可以像使用其他任何类型的变量一样使用枚举常量。枚举常量在编译时就被解析为对应的枚举类型对象。

Day day = Day.MONDAY;  
System.out.println(day); // 输出 MONDAY

方法

枚举可以包含字段、方法和构造函数。但是，枚举的构造函数默认是私有的，以防止外部代码实例化枚举。

public enum Color {  
    RED("红色"), GREEN("绿色"), BLUE("蓝色");  
  
    private final String description;  
  
    Color(String description) {  
        this.description = description;  
    }  
  
    public String getDescription() {  
        return this.description;  
    }  
}  
  
System.out.println(Color.RED.getDescription()); // 输出 红色
//
// 在这个例子中，Color枚举类有一个私有字段description和一个接受字符串参数的构造函数。每个枚举常量在声明时都通过调用构造函数来初始化其description字段。

遍历

你可以使用values()方法遍历枚举的所有值。

for (Day d : Day.values()) {  
    System.out.println(d);  
}

枚举与switch

枚举与switch语句配合使用非常方便，因为switch语句可以接受枚举类型作为条件表达式。

Day day = Day.MONDAY;  
  
switch (day) {  
    case MONDAY:  
        System.out.println("星期一");  
        break;  
    case FRIDAY:  
        System.out.println("星期五");  
        break;  
    default:  
        System.out.println("其他日子");  
}

实现接口

枚举类可以实现一个或多个接口，并定义实现这些接口所需的方法。

interface Describable {  
    String describe();  
}  
  
public enum Planet implements Describable {  
    MERCURY, VENUS, EARTH;  
  
    @Override  
    public String describe() {  
        // 这里只是一个简单的实现，实际上你可以根据枚举常量的不同返回不同的描述  
        return this.name().toLowerCase() + " is a planet";  
    }  
}  
  
System.out.println(Planet.EARTH.describe()); // 输出 earth is a planet

另一种写法：

interface Behaviour {  
    void show();  
}  
  
public enum Animal implements Behaviour {  
    DOG {  
        @Override  
        public void show() {  
            System.out.println("Woof!");  
        }  
    },  
    CAT {  
        @Override  
        public void show() {  
            System.out.println("Meow!");  
        }  
    },  
    BIRD {  
        @Override  
        public void show() {  
            System.out.println("Tweet!");  
        }  
    };  
  
    // 示例：一个静态方法，遍历所有动物并显示它们的行为  
    public static void showAllAnimals() {  
        for (Animal animal : Animal.values()) {  
            animal.show();  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        showAllAnimals();  
    }  
}

带构造器和方法的枚举

public enum Season {  
    SPRING("Spring"), SUMMER("Summer"), AUTUMN("Autumn"), WINTER("Winter");  
  
    private final String description;  
  
    // 私有构造器  
    Season(String description) {  
        this.description = description;  
    }  
  
    // 公开方法  
    public String getDescription() {  
        return description;  
    }  
  
    // 示例方法，根据季节返回活动建议  
    public String getActivitySuggestion() {  
        switch (this) {  
            case SPRING:  
                return "Go for a hike or plant a garden.";  
            case SUMMER:  
                return "Go swimming or have a picnic.";  
            case AUTUMN:  
                return "Go apple picking or take a scenic drive.";  
            case WINTER:  
                return "Go skiing or build a snowman.";  
            default:  
                return "Enjoy the season!";  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        Season season = Season.SUMMER;  
        System.out.println(season.getDescription() + ": " + season.getActivitySuggestion());  
    }  
}

使用枚举作为Map的键

import java.util.EnumMap;  
import java.util.Map;  
  
public enum Day {  
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY  
}  
  
public class WorkHours {  
    public static void main(String[] args) {  
        Map<Day, Integer> workHours = new EnumMap<>(Day.class);  
  
        workHours.put(Day.MONDAY, 8);  
        workHours.put(Day.TUESDAY, 8);  
        workHours.put(Day.WEDNESDAY, 8);  
        workHours.put(Day.THURSDAY, 8);  
        workHours.put(Day.FRIDAY, 6); // 假设周五早些下班  
        // 周末不工作，所以不需要设置  
  
        for (Map.Entry<Day, Integer> entry : workHours.entrySet()) {  
            System.out.println(entry.getKey() + ": " + entry.getValue() + " hours");  
        }  
    }  
}

枚举中的抽象方法

public enum Operation {  
    PLUS {  
        @Override  
        public double apply(double x, double y) {  
            return x + y;  
        }  
    },  
    MINUS {  
        @Override  
        public double apply(double x, double y) {  
            return x - y;  
        }  
    },  
    MULTIPLY {  
        @Override  
        public double apply(double x, double y) {  
            return x * y;  
        }  
    },  
    DIVIDE {  
        @Override  
        public double apply(double x, double y) {  
            if (y == 0) throw new IllegalArgumentException("Cannot divide by zero");  
            return x / y;  
        }  
    };  
  
    // 抽象方法  
    public abstract double apply(double x, double y);  
  
    // 测试方法  
    public static void main(String[] args) {  
        System.out.println(Operation.PLUS.apply(10, 5));  // 输出 15.0  
        System.out.println(Operation.DIVIDE.apply(10, 2)); // 输出 5.0  
    }  
}

EnumSet与EnumMap:

EnumSet 和 EnumMap 是 Java 集合框架中专门为枚举（enum）类型设计的两个类。它们提供了比标准集合（如 HashSet 和 HashMap）更高的性能，特别是当集合中的元素是枚举类型时。这是因为它们内部利用了枚举的固有顺序和唯一性进行优化。

EnumSet

EnumSet 是一个不包含重复元素的集合，它专门为枚举类型设计。与普通的 Set 接口实现（如 HashSet）相比，EnumSet 在空间和时间上都有显著的优势，因为它内部使用位向量来表示集合中的元素，这种表示方法非常紧凑且高效。

主要特点：

类型安全：由于 EnumSet 的元素是枚举类型，因此在编译时就能保证类型安全。
性能高效：内部使用位向量存储元素，因此集合的创建、遍历和查找等操作都非常快。
丰富的构造函数：EnumSet 提供了多种构造函数，包括从类型（Class<E>）创建空集合、从现有集合创建新集合等。
迭代顺序：EnumSet 遍历元素的顺序是枚举的自然顺序（除非指定了另一种顺序），这对于需要按特定顺序处理枚举值的场景非常有用。

示例代码：

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }  
  
public class EnumSetExample {  
    public static void main(String[] args) {  
        EnumSet<Day> weekdays = EnumSet.range(Day.MONDAY, Day.FRIDAY);  
        for (Day day : weekdays) {  
            System.out.println(day);  
        }  
    }  
}

EnumMap

EnumMap 是一个映射（Map），其键是枚举类型。与普通的 Map 接口实现（如 HashMap）相比，EnumMap 提供了更高的性能，因为它内部使用数组来存储键值对，并利用枚举的索引作为数组的下标。

主要特点：

类型安全：由于 EnumMap 的键是枚举类型，因此在编译时就能保证类型安全。
性能高效：内部使用数组存储键值对，使得查找、插入和删除操作都非常快。
自然顺序：EnumMap 遍历键的顺序是枚举的自然顺序（除非指定了另一种顺序）。
内存紧凑：由于内部使用数组，且数组的大小固定为枚举类型的常量数，因此 EnumMap 的内存使用非常紧凑。

示例代码：

enum Color { RED, GREEN, BLUE }  
  
public class EnumMapExample {  
    public static void main(String[] args) {  
        EnumMap<Color, Integer> count = new EnumMap<>(Color.class);  
        count.put(Color.RED, 1);  
        count.put(Color.GREEN, 2);  
        count.put(Color.BLUE, 3);  
  
        for (Map.Entry<Color, Integer> entry : count.entrySet()) {  
            System.out.println(entry.getKey() + ": " + entry.getValue());  
        }  
    }  
}

总之，EnumSet 和 EnumMap 是 Java 集合框架中针对枚举类型优化的两个类，它们提供了类型安全、性能高效和内存紧凑的集合操作，是处理枚举类型数据时的首选集合类型。