目录
枚举类型用于定义一组固定的命名常量，在枚举类型中定义的每一个枚举常量都是枚举类型的一个实例，而且这个实例是不可变的。
枚举之前--int常量
枚举类型是Java 5版本引入的，在引入之前通常使用int常量来表示枚举类型，每一个int常量代表一个类型实例：
public class FruitMarket {
public static final int APPLE = 0;
public static final int ORANGE = 1;
public static final int BANANA = 2;
public static final int PINEAPPLE = 3;
}int常量的确能够轻松的列举出有限的枚举，但是有几个问题：
一是int常量没有安全性可言，只要是int值相同，不同类型的枚举都视为一样：
class FruitMarket {
public static final int APPLE = 0;
public static final int ORANGE = 1;
public static final int BANANA = 2;
public static final int PINEAPPLE = 3;
}
class VegetableMarket{
public static final int CARROT = 0;
public static final int CABBAGE = 1;
public static final int TOMATO = 2;
public static final int CUCUMBER = 3;
}
public class Application{
public static void main(String[] args){
VegetableMarket.CARROT == FruitMarket.APPLE;
}
}二是Int常量作为静态常量在编译时就会被赋值，一旦常量做了改变（或者有了新增），就要重新编译文件，而且要重新检视应用了这些常量的Java文件。
三是Int常量没有丰富的专用方法，比如遍历所有的枚举、将具体的常量值映射到对应的String标识等等，都要通过循环遍历和switch语句来实现。
四是Int常量受限于Integer类型，无法顺畅的加入一些枚举特有的方法。
但是Int常量的优势在于其存储的轻量化，所以如果是需要轻量化的枚举（比如只需要作为简单的标识作用），Int常量还是可以考虑的。
枚举类型
枚举类型的特性
Java的枚举类型对于枚举的使用做了针对性的设计，同时配置了齐全的功能。
一是通过公有的静态final域为每一个枚举常量导出一个枚举实例。
二是没有可以外部访问的构造器，进一步保证了外部无法通过构造器来新增枚举实例，但是可以允许有私有构造器，将枚举实例与相关的数据对应起来：
public enum Planet{
MERCURY(3.302e+23, 2.439e6),
VENUS(4.869e+24, 6.052e6),
EARTH(5.972e+24, 6.378e6),
MARS(6.419e+23, 3.396e6),
JUPITER(1.899e+27, 7.149e7),
SATURN(5.685e+26, 6.052e7),
URANUS(8.681e+25, 2.556e7),
NEPTUNE(1.002e+25, 1.188e6);
private double mass;
private double radius;
private double surfaceGravity;
private final static double G = 6.67300E-11;
Planet(double mass, double radius){
this.mass = mass;
this.radius = radius;
surfaceGravity = G*mass/(radius*radius);
}
}
//这里将Planet实例与其质量（mass）、半径（radius）和重力常量对应起来。三是枚举类提供了丰富的内置方法，其中绝大部分都是继承自java.lang.Enum基类（除了values()方法）：
-
name()：- 返回枚举常量的名称，即定义枚举时使用的标识符。
- 例如，对于枚举
Day.MONDAY，name()方法将返回"MONDAY"。
-
ordinal()：- 返回枚举常量在其枚举类型中的位置索引（从0开始）。
- 例如，对于枚举
Day.MONDAY，ordinal()方法将返回0，因为它是第一个枚举常量。
-
toString()：- 返回枚举常量的名称，与
name()方法相同。 - 默认情况下，
toString()方法返回枚举常量的名称。
- 返回枚举常量的名称，与
-
compareTo(E other)：- 比较两个枚举常量的顺序。
- 参数
other是同一枚举类型的另一个枚举常量。 - 返回值表示当前枚举常量与
other枚举常量的相对顺序。
-
valueOf(Class<E> enumType, String name)：- 静态方法，用于根据枚举类型的名称获取枚举常量。
- 如果名称匹配枚举类型中的一个常量，则返回该枚举常量；否则，抛出
IllegalArgumentException。
-
values()：- 静态方法，返回枚举类型的数组，包含该枚举类型的所有枚举常量。
- 这个方法可以用来遍历枚举类型的全部常量。
可以看到绝大部分方法都是继承了Object类和实现Comparable与Serializable接口所实现的方法。
自定义方法和域的设置
实例的统一行为
枚举类型由于不是基本数据类型，所以在构建的时候可以添加自定义方法和域，这些方法和域可以实现将各种支持性数据和它对应的常量对应起来（比如将Apple实例与其图片、介绍等内容关联起来），自定义域的定义的在前面说私有构造器的时候已经举过相关例子了，这里把自定义的方法扩展一下：
public enum Planet{
MERCURY(3.302e+23, 2.439e6),
VENUS(4.869e+24, 6.052e6),
EARTH(5.972e+24, 6.378e6),
MARS(6.419e+23, 3.396e6),
JUPITER(1.899e+27, 7.149e7),
SATURN(5.685e+26, 6.052e7),
URANUS(8.681e+25, 2.556e7),
NEPTUNE(1.002e+25, 1.188e6);
private final double mass;
private final double radius;
private final double surfaceGravity;
private final static double G = 6.67300E-11;
Planet(double mass, double radius){
this.mass = mass;
this.radius = radius;
surfaceGravity = G*mass/(radius*radius);
}
public double getMass(){
return mass;
}
public double getRadius(){
return radius;
}
public double surfaceWeight(double mass){
return mass*surfaceGravity;
}
}这里作者强调由于枚举类本身是不可变的，因此所有的域都要改成final，而且要做好封装，能私有化的尽量都私有化，通过公有接口来调用。
实例的不同行为
比如四则运算，每一个枚举实例的运算规则都不相同，这种实例的不同行为可以有多种实现方式：
switch语句
public enum Operation{
PLUS, MINUS, TIMES, DIVIDE;
public double apply(double x, double y){
switch(this){
case PLUS: return x+y;
case MINUS: return x-y;
case TIMES: return x*y;
case DIVIDE: return x/y;
}
throw new AssertionError("Unknow op:"+this);
}
}
//由switch语句来实现apply方法这种方法比较简洁，但是有几个问题：
一是必须声明throw方法，不然无法通过编译，但是枚举类保证了实例的范围，所以这段代码是永远不会被执行的。
二是一旦新增了枚举常量，就需要记得给switch方法中再增加一个case。
抽象方法
package Operation;
public enum BasicOperation{
PLUS("+"){
public double apply(double x, double y){
return x + y;
}
},
MINUS("-"){
public double apply(double x, double y){
return x-y;
}
},
MULTIPLY("*"){
public double apply(double x, double y){
return x * y;
}
},
DIVIDE("/"){
public double apply(double x, double y){
return x / y;
}
};
public abstract double apply(double x, double y);//在枚举类中设置抽象方法，然后让各个实例来自行实现。
private final String symbol;
BasicOperation(String symbol){
this.symbol = symbol;
}
@Override
public String toString(){
return symbol;
}
}
这个方法将公共方法抽象到了类中，实现了高内聚，但是还可以进一步的抽象为公共接口。
公共接口
package Operation;
//将apply方法抽象到接口当中
public interface Operation {
public double apply(double x, double y);
}
//具体的枚举类通过实现接口来调用接口方法apply
public enum BasicOperation implements Operation{
PLUS("+"){
public double apply(double x, double y){
return x + y;
}
},
MINUS("-"){
public double apply(double x, double y){
return x-y;
}
},
MULTIPLY("*"){
public double apply(double x, double y){
return x * y;
}
},
DIVIDE("/"){
public double apply(double x, double y){
return x / y;
}
};
private final String symbol;
BasicOperation(String symbol){
this.symbol = symbol;
}
@Override
public String toString(){
return symbol;
}
}
公共接口的方式进一步提升了抽象的层次，使得任何枚举类都可以通过实现接口来调用相关方法，这种方式适合新建另一个枚举类的时候使用（比如新建一个AdvancedOperation类实现了幂运算和开方运算）。
策略枚举
策略枚举是一种较为特殊的方式，它适用的场景是对于枚举实例设置一个新的分类方式，并基于这个分类方式实行差异化的方法，比如把周一到周日分为工作日和休息日，其中工作日超过八小时的工作时间会产生加班工资，在休息日所有工作都产生加班工资：
package PayrollDay;
public class PayrollDay {
MONDAY(PayType.WEEKDAY),TUESDAY(PayType.WEEKDAY),WEDNESDAY(PayType.WEEKDAY),THURSDAY(PayType.WEEKDAY),FRIDAY(PayType.WEEKDAY),SATURDAY(PayType.WEEKEND),SUNDAY(PayType.WEEKEND);
private final PayType, payType;
GoodPayrollDay(PayType payType){
this.payType = payType;
}
int pay(int minutesWorked, int payRate){
return payType.pay(minutesWorked, payRate);
}
}
//这里将PayTYpe设置为新的分类方式，并且作为基本枚举类PayrollDay的一个域映射到每一个实例上，而pay的实现方法都定义在PayTYpe中
enum PayType{
WEEKDAY{
int overtimePay(int minutes, int PayRate){
return minutes <= MINS_PER_SHIFT ? 0 : (minutes - MINS_PER_SHIFT) * PayRate/2;
};
},
WEEKEND{int overtimePay(int minutes, int PayRate){
return minutes * PayRate/2;
}
};
abstract int overtimePay(int minutes, int PayRate);
private static final int MINS_PER_SHIFT = 8 * 60;
int pay(int minutes, int PayRate){
int basePay = minutes*PayRate;
return basePay + overtimePay(minutes, PayRate);
}
}
用实例域代替默认序数
枚举类有默认实现的ordinal()方法来返回每个枚举常量在类型中对应的数字位置，但是这个数字并不是程序员可以直接控制的，而且没有实际的意义，因此作者建议自行定义关联值并将它保存在一个实例域中：
package Ensemble;
public enum ensemble {
SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5), SEXTET(6), SEPTET(7), OCTET(8), DOUBLE_QUARTET(8), NONET(9), DECTET(10);
private int numberOfMusicians;
ensemble(int size){
this.numberOfMusicians = size;
}
public int numberOfMusicians(){
return numberOfMusicians;
}
}
枚举集合
EnumSet
EnumSet是同一个枚举类常量的集合，在枚举类出现之前的int常量时期，往往使用位域操作来实现int常量的集合运算：
public class text {
public static final int STYLE_BOLD = 1<<0;
public static final int STYLE_ITALIC = 1<<1;
public static final int STYLE_UNDERLINE = 1<<2;
public static final int STYLE_STRIKETHROUGH = 1<<3;
public static int applyStyle(int style){
return style;
};
}
这里由int常量来表示枚举，由于int有32位，这意味着可以使用int类型来表示最多32中不同的状态，并且通过or运算来做并集（比如将0001和1000合并成为1001）。
但是这种方式有很大的问题，一是它继承了int常量所有的缺陷，二是难以遍历位域运算形成的集合，三是在编写API的时候，必须先预测最多需要多少位，同时要选择合适的类型（如果特性较多可能要使用long类型），不然会导致溢出。
所以EnumSet可以完美解决上述的缺陷，它实现了Set接口的集合处理方法，使得对于集合的各种处理功能更加丰富。
public class Text{
public enum Style{BOLD, ITALIC, UNDERLINE, STRIKETHROUGH}
publi void applyStyles(Set<Style> styles){};
}
Text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));
EnumMap
EnumMap即以枚举常量为key的Map，在实现EnumMap之前一般通过序数索引来构建枚举实例为key对应的Map类型，而序数索引一般由ordinal方法实现。
package Plant;
import java.util.HashSet;
import java.util.Set;
public class BadApplication {
public static void main(String[] args) {
Set<Plant> garden = new HashSet<>();
garden.add(new Plant("Violets", Plant.LifeCycle.ANNUAL));
garden.add(new Plant("Radishes", Plant.LifeCycle.PERENNIAL));
garden.add(new Plant("Apple", Plant.LifeCycle.BIENNIAL));
garden.add(new Plant("Pears", Plant.LifeCycle.BIENNIAL));
garden.add(new Plant("Grapes",Plant.LifeCycle.ANNUAL));
Set<Plant>[] plantByLifeCycle = (Set<Plant>[]) new Set[Plant.LifeCycle.values().length];
for(int i = 0; i < Plant.LifeCycle.values().length; i++){
plantByLifeCycle[i] = new HashSet<>();
}
for(Plant p : garden){
plantByLifeCycle[p.getLifeCycle().ordinal()].add(p);
}
for(int i=0; i<plantByLifeCycle.length; i++){
System.out.printf("%s: %s%n", Plant.LifeCycle.values()[i], plantByLifeCycle[i]);
}
}
}
这方法首先数组与泛型合用时程序需要进行未受检的转换，不然会在编译是出告警；二是ordinal()方法返回的序数和plantByLifeCycle序数的对应需要人工进行核对，程序是不保证的。
而EnumMap可以很好的解决这个问题：
public class Application {
public static void main(String[] args) {
Set<Plant> garden = new HashSet<>();
garden.add(new Plant("Violets", Plant.LifeCycle.ANNUAL));
garden.add(new Plant("Radishes", Plant.LifeCycle.PERENNIAL));
garden.add(new Plant("Apple", Plant.LifeCycle.BIENNIAL));
garden.add(new Plant("Pears", Plant.LifeCycle.BIENNIAL));
garden.add(new Plant("Grapes",Plant.LifeCycle.ANNUAL));
Map<Plant.LifeCycle, List<Plant>> plantByLifeCycle = new EnumMap<>(Plant.LifeCycle.class);
for(Plant.LifeCycle lc: Plant.LifeCycle.values()){
plantByLifeCycle.put(lc, new ArrayList<Plant>());
}
for(Plant p: garden){
plantByLifeCycle.get(p.getLifeCycle()).add(p);
}
for (Plant.LifeCycle lc : Plant.LifeCycle.values()) {
System.out.println(lc+": ");
for (Plant plant : plantByLifeCycle.get(lc)) {
System.out.println(plant);
}
System.out.println("\n");
}
}这里有的读者会质疑EnumMap和普通Map相比在起初构建时并无显著不同，那它的优势在哪里：
- 类型安全：
EnumMap的键必须是某个枚举类型的枚举值。这意味着在编译时就会检查键的有效性，从而避免了运行时可能出现的ClassCastException。 - 高效：
EnumMap内部使用数组实现，因此在查找枚举键时非常高效。这是因为枚举类型的枚举值数量是固定的，而且是已知的，因此EnumMap可以预先计算出每个枚举值的位置。 - 有序：
EnumMap会按照枚举值的声明顺序来维护键的顺序。这意味着当你遍历EnumMap时，键的顺序是确定的，这有助于简化代码逻辑。
除了上述方法之外，作者还展示了如何使用Stream的形式来实现EnumMap:
System.out.println(Arrays.stream(garden).collect(groupingBy(p->p.lifeCycle, ()->new EnumMap<>(LifeCycle.class), Collector.toSet())));区别在于后一种方式可以仅包含garden涉及的枚举类型，而第一种的key中会列示所有的枚举常量。
这里补充一下Stream的用法解析：
- 使用 Stream API：使用
Arrays.stream(garden)将列表转换为 Stream。 - 分组：使用
Collectors.groupingBy方法按Plant的lifeCycle属性进行分组。Plant::getLifeCycle：指定分组键的提取器。() -> new EnumMap<>(LifeCycle.class)：指定创建EnumMap的工厂方法。Collectors.toSet()：指定收集器，将每个分组的结果收集到Set中。
1142
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
