【搞定Java基础】第14篇：Java 枚举类型（Enum）

骑猪看日落 2022-03-25 10:38 302阅读 0赞

本文转发自：[https://blog.csdn.net/javazejian/article/details/71333103][https_blog.csdn.net_javazejian_article_details_71333103]

## **本文目录：** ##

**1、理解枚举类型**

1.1、枚举的定义

1.2、枚举实现原理

1.3、枚举的常见方法

**2、枚举与 Class 对象**

**3、枚举的进阶用法**

3.1、向enum类添加方法与自定义构造函数

3.2、关于覆盖 enum 类方法

3.3、enum 类中定义抽象方法

**4、枚举与 switch**

**5、枚举与单例模式**

**6、EnumMap**

6.1、EnumMap基本用法

6.2、EnumMap实现原理剖析

**7、EnumSet**

7.1、EnumSet用法

7.2、EnumSet 实现原理剖析

--------------------

# 1、理解枚举类型 #

**枚举类型是 Java 5 中新增特性的一部分，它是一种特殊的数据类型，之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。**下面先来看看什么是枚举？如何定义枚举？

## 1.1、枚举的定义 ##

回忆一下下面的程序，这是在没有枚举类型时定义常量常见的方式：

// 使用普通方式定义日期常量
    public class DayDemo {
     
    	public static final int MONDAY = 1;
    
    	public static final int TUESDAY = 2;
    
    	public static final int WEDNESDAY = 3;
    
    	public static final int THURSDAY = 4;
    
    	public static final int FRIDAY = 5;
    
    	public static final int SATURDAY = 6;
    
    	public static final int SUNDAY = 7;
    
    }

上述的常量定义常量的方式称为 int 枚举模式，这样的定义方式并没有什么错，但它存在许多不足，如在类型安全和使用方便性上并没有多少好处，如果存在定义 int 值相同的变量，混淆的几率还是很大的，编译器也不会提出任何警告，因此这种方式在枚举出现后并不提倡，现在我们利用枚举类型来重新定义上述的常量，同时也感受一把枚举定义的方式，如下定义周一到周日的常量：

// 枚举类型，使用关键字enum
    enum Day {
    	MONDAY, TUESDAY, WEDNESDAY,
    	THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

相当简洁，在定义枚举类型时我们使用的关键字是 enum，与 class 关键字类似，只不过前者是定义枚举类型，后者是定义类类型。枚举类型 Day 中分别定义了从周一到周日的值，这里要注意，**值一般是大写的字母，多个值之间以逗号分隔**。同时我们应该知道的是枚举类型可以像类(class)类型一样，定义为一个单独的文件，当然也可以定义在其它类内部，更重要的是**枚举常量在类型安全性和便捷性都很有保证，如果出现类型问题编译器也会提示我们改进，但务必记住枚举表示的类型其取值是必须有限的，也就是说每个值都是可以枚举出来的，比如上述描述的一周共有七天。**那么该如何使用呢？如下：

public class EnumDemo {
    
    	public static void main(String[] args){
    		// 直接引用
    		Day day = Day.MONDAY;
    	}
    
    }
    // 定义枚举类型
    enum Day {
    	MONDAY, TUESDAY, WEDNESDAY,
    	THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

就像上述代码那样，直接引用枚举的值即可，这便是枚举类型的最简单模型。

## 1.2、枚举实现原理 ##

我们大概了解了枚举类型的定义与简单使用后，现在有必要来了解一下枚举类型的基本实现原理。实际上在使用关键字 enum 创建枚举类型并编译后，编译器会为我们生成一个相关的类，这个类继承了 Java API 中的 java.lang.Enum 类，也就是说通过关键字 enum 创建枚举类型在编译后事实上也是一个类类型而且该类继承自 java.lang.Enum 类。下面我们编译前面定义的 EnumDemo.java 并查看生成的 class 文件来验证这个结论：

// 反编译Day.class
    final class Day extends Enum
    {
    	// 编译器为我们添加的静态的values()方法
    	public static Day[] values()
    	{
    		return (Day[])$VALUES.clone();
    	}
    	// 编译器为我们添加的静态的valueOf()方法，注意间接调用了Enum也类的valueOf方法
    	public static Day valueOf(String s)
    	{
    		return (Day)Enum.valueOf(com/zju/enumdemo/Day, s);
    	}
    	// 私有构造函数
    	private Day(String s, int i)
    	{
    		super(s, i);
    	}
    	// 前面定义的7种枚举实例
    	public static final Day MONDAY;
    	public static final Day TUESDAY;
    	public static final Day WEDNESDAY;
    	public static final Day THURSDAY;
    	public static final Day FRIDAY;
    	public static final Day SATURDAY;
    	public static final Day SUNDAY;
    	private static final Day $VALUES[];
    
    	static 
    	{    
    		// 实例化枚举实例
    		MONDAY = new Day("MONDAY", 0);
    		TUESDAY = new Day("TUESDAY", 1);
    		WEDNESDAY = new Day("WEDNESDAY", 2);
    		THURSDAY = new Day("THURSDAY", 3);
    		FRIDAY = new Day("FRIDAY", 4);
    		SATURDAY = new Day("SATURDAY", 5);
    		SUNDAY = new Day("SUNDAY", 6);
    		$VALUES = (new Day[] {
    			MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    		});
    	}
    }

从反编译的代码可以看出编译器确实帮助我们生成了一个 Day 类(注意该类是 final 类型的，将无法被继承)而且该类继承自 java.lang.Enum 类，该类是一个抽象类(稍后我们会分析该类中的主要方法)。除此之外，编译器还帮助我们生成了 7 个 Day 类型的实例对象分别对应枚举中定义的 7 个日期，这也充分说明了我们前面使用关键字 enum 定义的 Day 类型中的每种日期枚举常量也是实实在在的 Day 实例对象，只不过代表的内容不一样而已。注意编译器还为我们生成了两个静态方法，分别是 values() 和 valueOf()，稍后会分析它们的用法。

**到此我们也就明白了，使用关键字 enum 定义的枚举类型，在编译期后，也将转换成为一个实实在在的类，而在该类中，会存在每个在枚举类型中定义好变量的对应实例对象**。如上述的 MONDAY 枚举类型对应 public static final Day MONDAY;，同时编译器会为该类创建两个方法，分别是 values() 和 valueOf()。到此相信我们对枚举的实现原理也比较清晰，下面我们深入了解一下 java.lang.Enum 类以及 values() 和 valueOf() 的用途。

## 1.3、枚举的常见方法 ##

### 1.3.1  Enum抽象类常见方法 ###

Enum 是所有 Java 语言枚举类型的公共基本类（注意Enum是抽象类），以下是它的常见方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70][]

这里主要说明一下 ordinal() 方法，该方法获取的是**枚举变量在枚举类中声明的顺序**，下标从 0 开始，如日期中的MONDAY 在第一个位置，那么 MONDAY 的 ordinal 值就是0，如果 MONDAY 的声明位置发生变化，那么 ordinal 方法获取到的值也随之变化，注意在大多数情况下我们都不应该首先使用该方法，毕竟它总是变幻莫测的。

compareTo(E o) 方法则是比较枚举的大小，注意其内部实现是根据每个枚举的 ordinal 值大小进行比较的。name()  方法与 toString() 几乎是等同的，都是输出变量的字符串形式。

至于 valueOf(Class<T> enumType, String name) 方法则是根据枚举类的 Class 对象和枚举名称获取枚举常量，注意该方法是静态的，后面在枚举单例时，我们还会详细分析该方法，下面的代码演示了上述方法：

// 枚举类
    enum Day {
    	MONDAY, TUESDAY, WEDNESDAY,
    	THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }
    
    public class EnumDemo {
    
    	public static void main(String[] args){
    
    		// 创建枚举数组
    		Day[] days = new Day[]{Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY,
    				Day.THURSDAY, Day.FRIDAY, Day.SATURDAY, Day.SUNDAY};
    
    		for (int i = 0; i <days.length ; i++) {
    			System.out.println("day["+ i +"].ordinal():" + days[i].ordinal());
    		}
    
    		System.out.println("-------------------------------------");
    		// 通过compareTo方法比较,实际上其内部是通过ordinal()值比较的
    		System.out.println("days[0].compareTo(days[1]):" + days[0].compareTo(days[1]));
    		System.out.println("days[0].compareTo(days[1]):" + days[0].compareTo(days[2]));
    
    		// 获取该枚举对象的Class对象引用,当然也可以通过getClass方法
    		Class<?> clazz = days[0].getDeclaringClass();
    		System.out.println("clazz:"+clazz);
    
    		System.out.println("-------------------------------------");
    
    		// name()
    		System.out.println("days[0].name():" + days[0].name());
    		System.out.println("days[1].name():" + days[1].name());
    		System.out.println("days[2].name():" + days[2].name());
    		System.out.println("days[3].name():" + days[3].name());
    
    		System.out.println("-------------------------------------");
    
    		System.out.println("days[0].toString():" + days[0].toString());
    		System.out.println("days[1].toString():" + days[1].toString());
    		System.out.println("days[2].toString():" + days[2].toString());
    		System.out.println("days[3].toString():" + days[3].toString());
    
    		System.out.println("-------------------------------------");
    
    		Day d = Enum.valueOf(Day.class,days[0].name());
    		Day d2 = Day.valueOf(Day.class,days[0].name());
    		System.out.println("d:" + d);
    		System.out.println("d2:" + d2);
    	}
    	
    	
     /**
     执行结果:
       day[0].ordinal():0
       day[1].ordinal():1
       day[2].ordinal():2
       day[3].ordinal():3
       day[4].ordinal():4
       day[5].ordinal():5
       day[6].ordinal():6
       -------------------------------------
       days[0].compareTo(days[1]):-1
       days[0].compareTo(days[1]):-2
       clazz:class com.zejian.enumdemo.Day
       -------------------------------------
       days[0].name():MONDAY
       days[1].name():TUESDAY
       days[2].name():WEDNESDAY
       days[3].name():THURSDAY
       -------------------------------------
       days[0].toString():MONDAY
       days[1].toString():TUESDAY
       days[2].toString():WEDNESDAY
       days[3].toString():THURSDAY
       -------------------------------------
       d:MONDAY
       d2:MONDAY
       */
    
    }

到此对于抽象类 Enum 类的基本内容就介绍完了，这里提醒大家一点，Enum 类内部会有一个构造函数，该构造函数只能有编译器调用，我们是无法手动操作的，不妨看看 Enum 类的主要源码：

// 实现了Comparable
    public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
    
    	private final String name;   // 枚举字符串名称
    
    	public final String name() {
    		return name;
    	}
    
    	private final int ordinal;  // 枚举顺序值
    
    	public final int ordinal() {
    		return ordinal;
    	}
    
    	//枚举的构造方法，只能由编译器调用
    	protected Enum(String name, int ordinal) {
    		this.name = name;
    		this.ordinal = ordinal;
    	}
    
    	public String toString() {
    		return name;
    	}
    
    	public final boolean equals(Object other) {
    		return this==other;
    	}
    
    	// 比较的是ordinal值
    	public final int compareTo(E o) {
    		Enum<?> other = (Enum<?>)o;
    		Enum<E> self = this;
    		if (self.getClass() != other.getClass() && // optimization
    			self.getDeclaringClass() != other.getDeclaringClass())
    			throw new ClassCastException();
    		return self.ordinal - other.ordinal;//根据ordinal值比较大小
    	}
    
    	@SuppressWarnings("unchecked")
    	public final Class<E> getDeclaringClass() {
    		// 获取class对象引用，getClass()是Object的方法
    		Class<?> clazz = getClass();
    		// 获取父类Class对象引用
    		Class<?> zuper = clazz.getSuperclass();
    		return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
    	}
    
    
    	public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
    		// enumType.enumConstantDirectory()获取到的是一个map集合，key值就是name值，value则是枚举变量值   
    		// enumConstantDirectory是class对象内部的方法，根据class对象获取一个map集合的值       
    		T result = enumType.enumConstantDirectory().get(name);
    		if (result != null)
    			return result;
    		if (name == null)
    			throw new NullPointerException("Name is null");
    		throw new IllegalArgumentException(
    			"No enum constant " + enumType.getCanonicalName() + "." + name);
    	}
    
    	// .....省略其他没用的方法
    }

通过 Enum 源码，可以知道，Enum 实现了 Comparable 接口，这也是可以使用 compareTo 比较的原因，当然 Enum 构造函数也是存在的，该函数只能由编译器调用，毕竟我们只能使用 enum 关键字定义枚举，其他事情就放心交给编译器吧。

// 由编译器调用
    protected Enum(String name, int ordinal) {
            this.name = name;
            this.ordinal = ordinal;
    }

### 1.3.2  编译器生成的 Values 方法与 ValueOf 方法 ###

values() 方法和 valueOf(String name) 方法是编译器生成的 static 方法，因此从前面的分析中，在 Enum 类中并没出现values() 方法，但 valueOf() 方法还是有出现的，只不过编译器生成的 valueOf() 方法需传递一个 name 参数，而 Enum 自带的静态方法 valueOf() 则需要传递两个方法，从前面反编译后的代码可以看出，编译器生成的 valueOf 方法最终还是调用了Enum 类的 valueOf 方法，下面通过代码来演示这两个方法的作用：

Day[] days2 = Day.values();
    System.out.println("day2:" + Arrays.toString(days2));
    Day day = Day.valueOf("MONDAY");
    System.out.println("day:" + day);
    
    /**
     输出结果:
     day2:[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
     day:MONDAY
     */

从结果可知道，**values() 方法的作用就是获取枚举类中的所有变量，并作为数组返回。而 valueOf(String name) 方法与Enum 类中的 valueOf 方法的作用类似根据名称获取枚举变量**，只不过编译器生成的 valueOf 方法更简洁些只需传递一个参数。这里我们还必须注意到，由于 values() 方法是由编译器插入到枚举类中的 static方法，所以如果我们将枚举实例向上转型为 Enum，那么 values() 方法将无法被调用，因为 Enum 类中并没有 values() 方法，valueOf() 方法也是同样的道理，注意是一个参数的。

// 正常使用
    Day[] ds = Day.values();
    // 向上转型Enum
    Enum e = Day.MONDAY;
    // 无法调用,没有此方法
    // e.values();

--------------------

# **2、枚举与 Class 对象** #

上述我们提到当枚举实例向上转型为 Enum 类型后，values() 方法将会失效，也就无法一次性获取所有枚举实例变量，但是由于 Class 对象的存在，即使不使用 values() 方法，还是有可能一次获取到所有枚举实例变量的，在 Class 对象中存在如下方法：

![20190120160225361.png][]

因此通过 getEnumConstants() 方法，同样可以[轻而易举][Link 1]地获取所有枚举实例变量下面通过代码来演示这个功能：

// 正常使用
    Day[] ds = Day.values();
    // 向上转型Enum
    Enum e = Day.MONDAY;
    // 无法调用,没有此方法
    // e.values();
    // 获取class对象引用
    Class<?> clasz = e.getDeclaringClass();
    if(clasz.isEnum()) {
    	Day[] dsz = (Day[]) clasz.getEnumConstants();
    	System.out.println("dsz:" + Arrays.toString(dsz));
    }
    
    /**
       输出结果:
       dsz:[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
     */

正如上述代码所展示，通过 Enum 的 Class 对象的 getEnumConstants 方法，我们仍能一次性获取所有的枚举实例常量。

--------------------

# 3、枚举的进阶用法 #

**在前面的分析中，我们都是基于简单枚举类型的定义，也就是在定义枚举时只定义了枚举实例类型，并没定义方法或者成员变量，实际上使用关键字 enum 定义的枚举类，除了不能使用继承(因为编译器会自动为我们继承 Enum 抽象类而 Java 只支持单继承，因此枚举类是无法手动实现继承的)，可以把 enum 类当成常规类，也就是说我们可以向 enum 类中添加方法和变量，甚至是 mian 方法**，下面就来感受一把。

## 3.1、向enum类添加方法与自定义构造函数 ##

重新定义一个日期枚举类，带有 desc 成员变量描述该日期的对于中文描述，同时定义一个 getDesc 方法，返回中文描述内容，自定义私有构造函数，在声明枚举实例时传入对应的中文描述，代码如下：

public enum Day2 {
    	
    	MONDAY("星期一"),
    	TUESDAY("星期二"),
    	WEDNESDAY("星期三"),
    	THURSDAY("星期四"),
    	FRIDAY("星期五"),
    	SATURDAY("星期六"),
    	SUNDAY("星期日");     // 记住要用分号结束
    
    	private String desc;  // 中文描述
    
    	/**
    	 * 私有构造,防止被外部调用
    	 * @param desc
    	 */
    	private Day2(String desc){
    		this.desc = desc;
    	}
    
    	/**
    	 * 定义方法,返回描述,跟常规类的定义没区别
    	 * @return
    	 */
    	public String getDesc(){
    		return desc;
    	}
    
    	public static void main(String[] args){
    		for (Day2 day : Day2.values()) {
    			System.out.println("name:" + day.name() + ",desc:" + day.getDesc());
    		}
    	}
    
    	/**
    	 输出结果:
    	 name:MONDAY,desc:星期一
    	 name:TUESDAY,desc:星期二
    	 name:WEDNESDAY,desc:星期三
    	 name:THURSDAY,desc:星期四
    	 name:FRIDAY,desc:星期五
    	 name:SATURDAY,desc:星期六
    	 name:SUNDAY,desc:星期日
    	 */
    }

从上述代码可知，在 enum 类中确实可以像定义常规类一样声明变量或者成员方法。但是我们必须注意到，**如果打算在 enum 类中定义方法，务必在声明完枚举实例后使用分号分开，倘若在枚举实例前定义任何方法，编译器都将会报错，无法编译通过，同时即使自定义了构造函数且 enum 的定义结束，我们也永远无法手动调用构造函数创建枚举实例，毕竟这事只能由编译器执行。**

## 3.2、关于覆盖 enum 类方法 ##

既然 enum 类跟常规类的定义没什么区别（实际上 enum 还是有些约束的），那么覆盖父类的方法也不会是什么难事，可惜的是父类 Enum 中的定义的方法只有 toString 方法没有使用 final 修饰，因此只能覆盖 toString 方法，如下通过覆盖toString 省去了 getDesc 方法：

public enum Day2 {
    
    	MONDAY("星期一"),
    	TUESDAY("星期二"),
    	WEDNESDAY("星期三"),
    	THURSDAY("星期四"),
    	FRIDAY("星期五"),
    	SATURDAY("星期六"),
    	SUNDAY("星期日");     // 记住要用分号结束
    
    	private String desc;  // 中文描述
    
    	/**
    	 * 私有构造,防止被外部调用
    	 * @param desc
    	 */
    	private Day2(String desc){
    		this.desc=desc;
    	}
    
    	// 覆盖 toString方法
    	@Override
    	public String toString() {
    		return desc;
    	}
    
    
    	public static void main(String[] args){
    		for (Day2 day:Day2.values()) {
    			System.out.println("name:" + day.name() + ",desc:" + day.toString());
    		}
    	}
    
    	/**
    	 输出结果:
    	 name:MONDAY,desc:星期一
    	 name:TUESDAY,desc:星期二
    	 name:WEDNESDAY,desc:星期三
    	 name:THURSDAY,desc:星期四
    	 name:FRIDAY,desc:星期五
    	 name:SATURDAY,desc:星期六
    	 name:SUNDAY,desc:星期日
    	 */
    }

## **3.3、enum 类中定义抽象方法** ##

**与常规抽象类一样，enum 类允许我们为其定义抽象方法，然后使每个枚举实例都实现该方法，以便产生不同的行为方式。注意 abstract 关键字对于枚举类来说并不是必须的**，如下：

public enum EnumDemo3 {
    
    	FIRST{
    		@Override
    		public String getInfo() {
    			return "FIRST TIME";
    		}
    	},
    	SECOND{
    		@Override
    		public String getInfo() {
    			return "SECOND TIME";
    		}
    	};
    
    	/**
    	 * 定义抽象方法
    	 * @return
    	 */
    	public abstract String getInfo();
    
    	// 测试
    	public static void main(String[] args){
    		System.out.println("F:" + EnumDemo3.FIRST.getInfo());
    		System.out.println("S:" + EnumDemo3.SECOND.getInfo());
    		
    		/**
    		 输出结果:
    		 F:FIRST TIME
    		 S:SECOND TIME
    		 */
    	}
    }

通过这种方式就可以轻而易举地定义每个枚举实例的不同行为方式。我们可能注意到，enum 类的实例似乎表现出了多态的特性，可惜的是**枚举类型的实例终究不能作为类型传递使用**，就像下面的使用方式，编译器是不可能答应的：

// 无法通过编译，毕竟EnumDemo3.FIRST是个实例对象
    public void text(EnumDemo3.FIRST instance){ }

**3.4、enum 类与接口**

由于 Java 单继承的原因，enum 类并不能再继承其它类，但并不妨碍它实现接口，因此 enum 类同样是可以实现多接口的，如下：

interface food{
    	void eat();
    }
    
    interface sport{
    	void run();
    }
    
    public enum EnumDemo2 implements food ,sport{
    	FOOD,
    	SPORT,
    	; // 分号分隔
    
    	@Override
    	public void eat() {
    		System.out.println("eat.....");
    	}
    
    	@Override
    	public void run() {
    		System.out.println("run.....");
    	}
    }

有时候，我们可能需要对一组数据进行分类，比如进行食物菜单分类而且希望这些菜单都属于 food 类型，appetizer(开胃菜)、mainCourse(主菜)、dessert(点心)、Coffee 等，每种分类下有多种具体的菜式或食品，此时可以利用接口来组织，如下(代码引用自 Thinking in Java)：

public interface Food {
    	enum Appetizer implements Food {
    		SALAD, SOUP, SPRING_ROLLS;
    	}
    	enum MainCourse implements Food {
    		LASAGNE, BURRITO, PAD_THAI, LENTILS, HUMMOUS, VINDALOO;
    	}
    	enum Dessert implements Food {
    		TIRAMISU, GELATO, BLACK_FOREST_CAKE, FRUIT, CREME_CARAMEL;
    	}
    	enum Coffee implements Food {
    		BLACK_COFFEE, DECAF_COFFEE, ESPRESSO, LATTE, CAPPUCCINO, TEA, HERB_TEA;
    	}
    }
    
    public class TypeOfFood {
    	public static void main(String[] args) {
    		Food food = Appetizer.SALAD;
    		food = MainCourse.LASAGNE;
    		food = Dessert.GELATO;
    		food = Coffee.CAPPUCCINO;
    	}
    }

通过这种方式可以很方便组织上述的情景，同时确保每种具体类型的食物也属于 Food，现在我们利用一个枚举嵌套枚举的方式，把前面定义的菜谱存放到一个 Meal 菜单中，通过这种方式就可以统一管理菜单的数据了。

public enum Meal{
    
    	APPETIZER(Food.Appetizer.class),
    	MAINCOURSE(Food.MainCourse.class),
    	DESSERT(Food.Dessert.class),
    	COFFEE(Food.Coffee.class);
    	private Food[] values;
    	
    	private Meal(Class<? extends Food> kind) {
    		// 通过class对象获取枚举实例
    		values = kind.getEnumConstants();
    	}
    	
    	public interface Food {
    		enum Appetizer implements Food {
    			SALAD, SOUP, SPRING_ROLLS;
    		}
    		enum MainCourse implements Food {
    			LASAGNE, BURRITO, PAD_THAI, LENTILS, HUMMOUS, VINDALOO;
    		}
    		enum Dessert implements Food {
    			TIRAMISU, GELATO, BLACK_FOREST_CAKE, FRUIT, CREME_CARAMEL;
    		}
    		enum Coffee implements Food {
    			BLACK_COFFEE, DECAF_COFFEE, ESPRESSO, LATTE, CAPPUCCINO, TEA, HERB_TEA;
    		}
    	}
    }

--------------------

# **4、枚举与 switch** #

关于枚举与 switch 是个比较简单的话题，**使用 switch 进行条件判断时，条件参数一般只能是整型，字符型。而枚举型确实也被 switch 所支持，在 Java 1.7 后 switch 也对字符串进行了支持。**这里我们简单看一下 switch 与枚举类型的使用：

enum Color {GREEN, RED, BLUE}
    
    public class EnumDemo4 {
    
    	public static void printName(Color color){
    		switch (color){
    			case BLUE: // 无需使用Color进行引用
    				System.out.println("蓝色");
    				break;
    			case RED:
    				System.out.println("红色");
    				break;
    			case GREEN:
    				System.out.println("绿色");
    				break;
    		}
    	}
    
    	public static void main(String[] args){
    		printName(Color.BLUE);    // 蓝色
    		printName(Color.RED);     // 红色
    		printName(Color.GREEN);   // 绿色 
    	}
    }

需要注意的是使用在于 switch 条件进行结合使用时，无需使用 Color 引用。

--------------------

# 5、枚举与单例模式 #

单例模式可以说是最常使用的设计模式了，它的作用是确保某个类只有一个实例，自行实例化并向整个系统提供这个实例。在实际应用中，**线程池、缓存、日志对象、对话框对象常被设计成单例，总之，选择单例模式就是为了避免不一致状态。**下面我们将会简单说明单例模式的几种主要编写方式，从而对比出使用枚举实现单例模式的优点。首先看看饿汉式的单例模式：

// 恶汉式：基于classLoader机制避免了多线程的同步问题
    public class SingletonHungry {
    
    	private static SingletonHungry instance = new SingletonHungry();
    
    	private SingletonHungry() {
    	
    	}
    
    	public static SingletonHungry getInstance() {
    		return instance;
    	}
    }

显然这种写法比较简单，但**问题是无法做到延迟创建对象**，**事实上如果该单例类涉及资源较多，创建比较耗时间时，我们更希望它可以尽可能地延迟加载，从而减小初始化的负载，于是便有了如下的懒汉式单例**：

// 懒汉式：适合多线程安全
    public class SingletonLazy {
    
    	private static volatile SingletonLazy instance;
    
    	private SingletonLazy() {
    	
    	}
    
    	public static synchronized SingletonLazy getInstance() {
    		if (instance == null) {
    			instance = new SingletonLazy();
    		}
    		return instance;
    	}
    }

这种写法能够在多线程中很好的工作避免同步问题，同时也具备 lazy loading 机制，遗憾的是，由于 synchronized 的存在，效率很低，在单线程的情景下，完全可以去掉 synchronized，为了兼顾效率与性能问题，改进后代码如下：

public class Singleton {
    	private static volatile Singleton singleton = null;
    
    	private Singleton(){
    	
    	}
    
    	public static Singleton getSingleton(){
    		if(singleton == null){
    			synchronized (Singleton.class){
    				if(singleton == null){
    					singleton = new Singleton();
    				}
    			}
    		}
    		return singleton;
    	}    
    }

这种编写方式被称为 **“双重检查锁”****，主要在 getSingleton() 方法中，进行两次 null 检查。这样可以极大提升并发度，进而提升性能。****毕竟在单例中 new 的情况非常少，绝大多数都是可以并行的读操作，因此在加锁前多进行一次 null 检查就可以减少绝大多数的加锁操作，也就提高了执行效率。**

但是必须注意的是 volatile 关键字，该关键字有两层语义：

第一层语义是：**可见性**，可见性是指在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main Memory），所以其它线程会马上读取到已修改的值，关于工作内存和主内存可简单理解为高速缓存（直接与CPU打交道）和主存（日常所说的内存条），注意工作内存是线程独享的，主存是线程共享的。

volatile的第二层语义是：**禁止指令重排序优化**，我们写的代码（特别是多线程代码），由于编译器优化，在实际执行的时候可能与我们编写的顺序不同。**编译器只保证程序执行结果与源代码相同，却不保证实际指令的顺序与源代码相同**，这在单线程并没什么问题，然而一旦引入多线程环境，这种乱序就可能导致严重问题。volatile 关键字就可以从语义上解决这个问题，值得关注的是 volatile 的禁止指令重排序优化功能在 Java 1.5 后才得以实现，因此 1.5 前的版本仍然是不安全的，即使使用了 volatile 关键字。或许我们可以**利用静态内部类来实现更安全的机制**，静态内部类单例模式如下：

// 使用静态内部类实习单例模式
    public class SingletonInner {
    	private static class Holder {
    		private static SingletonInner singleton = new SingletonInner();
    	}
    
    	private SingletonInner(){
    	
    	}
    
    	public static SingletonInner getSingleton(){
    		return Holder.singleton;
    	}
    }

正如上述代码所展示的，我们把 Singleton 实例放到一个静态内部类中，这样可以避免了静态实例在 Singleton 类的加载阶段（类加载过程的其中一个阶段的，此时只创建了 Class 对象，关于 Class 对象可以看博主另外一篇博文， **[深入理解Java类型信息(Class对象)与反射机制][Java_Class]**）就创建对象，**毕竟静态变量初始化是在 SingletonInner 类初始化时触发的，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的**。从上述 4 种单例模式的写法中，似乎也解决了效率与懒加载的问题，但是它们都有两个共同的缺点：

*  **1、序列化可能会破坏单例模式，比较每次反序列化一个序列化的对象实例时都会创建一个新的实例**，解决方案如下：

// 测试例子(四种写解决方式雷同)
    public class Singleton implements java.io.Serializable {     
       public static Singleton INSTANCE = new Singleton();     
    
       protected Singleton() {    
       
       }  
    
       // 反序列时直接返回当前INSTANCE
       private Object readResolve() {     
                return INSTANCE;     
          }    
    }

*  ** 2、使用反射强行调用私有构造器，解决方式可以修改构造器，让它在创建第二个实例的时候抛异常**，如下：

public static Singleton INSTANCE = new Singleton();     
    private static volatile boolean flag = true;
    private Singleton(){
    	if(flag){
    		flag = false;   
    	}else{
    		throw new RuntimeException("The instance  already exists ！");
    	}
    }

如上所述，问题确实也得到了解决，但问题是我们为此付出了不少努力，即添加了不少代码，还应该注意到**如果单例类维持了其它对象的状态时，还需要使它们成为 transient 的对象**，这种就更复杂了，那有没有更简单更高效的呢？当然是有的，那就是枚举单例了，先来看看如何实现：

public enum  SingletonEnum {
    	
    	INSTANCE;
    	
    	private String name;
    	
    	public String getName(){
    		return name;
    	}
    	
    	public void setName(String name){
    		this.name = name;
    	}
    }

代码相当简洁，我们也可以像常规类一样编写 enum 类，为其添加变量和方法，访问方式也更简单，使用SingletonEnum.INSTANCE 进行访问，这样也就避免调用 getInstance 方法，更重要的是使用枚举单例的写法，我们完全不用考虑序列化和反射的问题。

**枚举序列化是由 JVM 保证的，每一个枚举类型和定义的枚举变量在 JVM 中都是唯一的，在枚举类型的序列化和反序列化上，Java 做了特殊的规定：在序列化时 Java 仅仅是将枚举对象的 name 属性输出到结果中，反序列化的时候则是通过java.lang.Enum 的 valueOf 方法来根据名字查找枚举对象。**

同时，编译器是不允许任何对这种序列化机制的定制的并禁用了 writeObject、readObject、readObjectNoData、writeReplace 和 readResolve 等方法，从而**保证了枚举实例的唯一性**，这里我们不妨再次看看 Enum 类的 valueOf 方法：

public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
    	T result = enumType.enumConstantDirectory().get(name);
    	
    	if (result != null)
    		return result;
    	
    	if (name == null)
    		throw new NullPointerException("Name is null");
    	throw new IllegalArgumentException("No enum constant " + enumType.getCanonicalName() + "." + name);
    }

实际上通过调用 enumType(Class对象的引用)的 enumConstantDirectory 方法获取到的是一个 Map 集合，在该集合中存放了以枚举 name 为 ke y和以枚举实例变量为 value 的 Key&Value 数据，因此通过 name 的值就可以获取到枚举实例，看看 enumConstantDirectory 方法源码：

Map<String, T> enumConstantDirectory() {
    	if (enumConstantDirectory == null) {
    		// getEnumConstantsShared最终通过反射调用枚举类的values方法
    		T[] universe = getEnumConstantsShared();
    		if (universe == null)
    			throw new IllegalArgumentException(getName() + " is not an enum type");
    		Map<String, T> m = new HashMap<>(2 * universe.length);
    		// map存放了当前enum类的所有枚举实例变量，以name为key值
    		for (T constant : universe)
    			m.put(((Enum<?>)constant).name(), constant);
    		enumConstantDirectory = m;
    	}
    	return enumConstantDirectory;
    }
    
    private volatile transient Map<String, T> enumConstantDirectory = null;

到这里我们也就可以看出枚举序列化确实不会重新创建新实例，JVM 保证了每个枚举实例变量的唯一性。再来看看反射到底能不能创建枚举，下面试图通过反射获取构造器并创建枚举：

public static void main(String[] args) throws IllegalAccessException, 
    		InvocationTargetException, InstantiationException, NoSuchMethodException {
    
    	// 获取枚举类的构造函数(前面的源码已分析过)
    	Constructor<SingletonEnum> constructor = SingletonEnum.class.getDeclaredConstructor(String.class,int.class);
    	constructor.setAccessible(true);
    	// 创建枚举
    	SingletonEnum singleton = constructor.newInstance("otherInstance",9);
    }

*  执行报错：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
        at zejian.SingletonEnum.main(SingletonEnum.java:38)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:498)
        at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

显然告诉我们不能使用反射创建枚举类，这是为什么呢？不妨看看 newInstance 方法源码：

public T newInstance(Object ... initargs) throws InstantiationException, 
    		IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    	
    	if (!override) {
    		if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
    			Class<?> caller = Reflection.getCallerClass();
    			checkAccess(caller, clazz, null, modifiers);
    		}
    	}
    	// 这里判断Modifier.ENUM是不是枚举修饰符，如果是就抛异常
    	if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    			throw new IllegalArgumentException("Cannot reflectively create enum objects");
    	ConstructorAccessor ca = constructorAccessor;   // read volatile
    	if (ca == null) {
    		ca = acquireConstructorAccessor();
    	}
    	@SuppressWarnings("unchecked")
    	T inst = (T) ca.newInstance(initargs);
    	return inst;
    }

源码很了然，确实无法使用反射创建枚举实例，也就是说明了创建枚举实例只有编译器能够做到而已。显然枚举单例模式确实是很不错的选择，因此我们推荐使用它。但是这总不是万能的，对于 android 平台这个可能未必是最好的选择，在android 开发中，内存优化是个大块头，而使用枚举时占用的内存常常是静态变量的两倍还多，因此 android 官方在内存优化方面给出的建议是尽量避免在 android 中使用 enum。但是不管如何，**关于单例，我们总是应该记住：线程安全，延迟加载，序列化与反序列化安全，反射安全是很重重要的。**

--------------------

# 6、EnumMap #

## 6.1、EnumMap基本用法 ##

先思考这样一个问题，现在我们有一堆 size 大小相同而颜色不同的数据，需要统计出每种颜色的数量是多少以便将数据录入仓库，定义如下枚举用于表示颜色 Color：

enum Color {
        GREEN, RED, BLUE, YELLOW
    }

我们有如下解决方案，使用 Map 集合来统计，key 值作为颜色名称，value 代表衣服数量，如下：

public class EnumMapDemo {
    	public static void main(String[] args){
    		
    		List<Clothes> list = new ArrayList<>();
    		list.add(new Clothes("C001",Color.BLUE));
    		list.add(new Clothes("C002",Color.YELLOW));
    		list.add(new Clothes("C003",Color.RED));
    		list.add(new Clothes("C004",Color.GREEN));
    		list.add(new Clothes("C005",Color.BLUE));
    		list.add(new Clothes("C006",Color.BLUE));
    		list.add(new Clothes("C007",Color.RED));
    		list.add(new Clothes("C008",Color.YELLOW));
    		list.add(new Clothes("C009",Color.YELLOW));
    		list.add(new Clothes("C010",Color.GREEN));
    		
    		// 方案1:使用HashMap
    		Map<String,Integer> map = new HashMap<>();
    		for (Clothes clothes : list){
    		   String colorName = clothes.getColor().name();
    		   Integer count = map.get(colorName);
    			if(count != null){
    				map.put(colorName, count + 1);
    			}else {
    				map.put(colorName, 1);
    			}
    		}
    
    		System.out.println(map.toString());
    
    		System.out.println("---------------");
    
    		// 方案2:使用EnumMap
    		Map<Color,Integer> enumMap = new EnumMap<>(Color.class);
    
    		for (Clothes clothes : list){
    			Color color = clothes.getColor();
    			Integer count = enumMap.get(color);
    			if(count! = null){
    				enumMap.put(color, count+1);
    			}else {
    				enumMap.put(color, 1);
    			}
    		}
    
    		System.out.println(enumMap.toString());
    	}
    
    	/**
    	 输出结果:
    	 {RED=2, BLUE=3, YELLOW=3, GREEN=2}
    	 ---------------
    	 {GREEN=2, RED=2, BLUE=3, YELLOW=3}
    	 */
    }

代码比较简单，我们使用两种解决方案，一种是 HashMap，一种 EnumMap，虽然都统计出了正确的结果，但是**EnumMap 作为枚举的专属的集合**，我们没有理由再去使用 HashMap，毕竟 EnumMap 要求其 Key 必须为 Enum 类型，因而使用 Color 枚举实例作为 key 是最恰当不过了，也避免了获取 name 的步骤，更重要的是 EnumMap 效率更高，因为其内部是通过数组实现的（稍后分析）。

**注意 EnumMap 的 key 值不能为 null，虽说是枚举专属集合，但其操作与一般的 Map 差不多，概括性来说 EnumMap 是专门为枚举类型量身定做的 Map 实现。****虽然使用其它的 Map（如：HashMap）也能完成相同的功能，但是使用 EnumMap 会更加高效，它只能接收同一枚举类型的实例作为键值且不能为 null，由于枚举类型实例的数量相对固定并且有限，所以 EnumMap 使用数组来存放与枚举类型对应的值，毕竟数组是一段连续的内存空间，根据程序局部性原理，效率会相当高。**下面我们来进一步了解 EnumMap 的用法，先看构造函数：

// 创建一个具有指定键类型的空枚举映射。
    EnumMap(Class<K> keyType) 
    // 创建一个其键类型与指定枚举映射相同的枚举映射，最初包含相同的映射关系（如果有的话）。     
    EnumMap(EnumMap<K,? extends V> m) 
    // 创建一个枚举映射，从指定映射对其初始化。
    EnumMap(Map<K,? extends V> m)

与 HashMap 不同，它需要传递一个类型信息，即 Class 对象，通过这个参数 EnumMap 就可以根据类型信息初始化其内部数据结构，另外两个只是初始化时传入一个 Map 集合，代码演示如下：

// 使用第一种构造
    Map<Color,Integer> enumMap = new EnumMap<>(Color.class);
    // 使用第二种构造
    Map<Color,Integer> enumMap2 = new EnumMap<>(enumMap);
    // 使用第三种构造
    Map<Color,Integer> hashMap = new HashMap<>();
    hashMap.put(Color.GREEN, 2);
    hashMap.put(Color.BLUE, 3);
    Map<Color, Integer> enumMap = new EnumMap<>(hashMap);

至于 EnumMap 的方法，跟普通的 map 几乎没有区别，注意**与 HashMap 的主要不同：构造方法需要传递类型参数和 EnumMap 保证 Key 顺序与枚举中的顺序一致，但请记住 Key 不能为 null。**

## 6.2、EnumMap实现原理剖析 ##

EnumMap 的源码有 700 多行，这里我们主要分析其内部存储结构，添加查找的实现，了解这几点，对应EnumMap内部实现原理也就比较清晰了，先看数据结构和构造函数：

public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
    	implements java.io.Serializable, Cloneable{
       
    	// Class对象引用
    	private final Class<K> keyType;
    
    	// 存储Key值的数组
    	private transient K[] keyUniverse;
    
    	// 存储Value值的数组
    	private transient Object[] vals;
    
    	// map的size
    	private transient int size = 0;
    
    	// 空map
    	private static final Enum<?>[] ZERO_LENGTH_ENUM_ARRAY = new Enum<?>[0];
    
    	// 构造函数
    	public EnumMap(Class<K> keyType) {
    		this.keyType = keyType;
    		keyUniverse = getKeyUniverse(keyType);
    		vals = new Object[keyUniverse.length];
    	}
    
        // ... 省略部分代码
    }

**EnumMap 继承了 AbstractMap 类，因此 EnumMap 具备一般 map 的使用方法。**keyType 表示类型信息，keyUniverse 表示键数组，存储的是所有可能的枚举值，vals 数组表示键对应的值，size 表示键值对个数。在构造函数中通过keyUniverse = getKeyUniverse(keyType);初始化了 keyUniverse 数组的值，内部存储的是所有可能的枚举值，接着初始化了存在 Value 值得数组 vals，其大小与枚举实例的个数相同，getKeyUniverse 方法实现如下：

// 返回枚举数组
    private static <K extends Enum<K>> K[] getKeyUniverse(Class<K> keyType) {
    	
    	// 最终调用到枚举类型的values方法，values方法返回所有可能的枚举值
    	return SharedSecrets.getJavaLangAccess().getEnumConstantsShared(keyType);
    }

从方法的返回值来看，返回类型是枚举数组，事实也是如此，最终返回值正是枚举类型的 values 方法的返回值，前面我们分析过 values 方法返回所有可能的枚举值，因此 keyUniverse 数组存储就是枚举类型的所有可能的枚举值。接着看 put 方法的实现：

*  **put 方法**

public V put(K key, V value) {
    	
    	// 检测key的类型
    	typeCheck(key);
    	// 获取存放value值得数组下标
    	int index = key.ordinal();
    	// 获取旧值
    	Object oldValue = vals[index];
    	// 设置value值
    	vals[index] = maskNull(value);
    	if (oldValue == null)
    		size++;
    	// 返回旧值
    	return unmaskNull(oldValue);  
    }

这里通过 typeCheck 方法进行了 key 类型检测，判断是否为枚举类型，如果类型不对，会抛出异常：

private void typeCheck(K key) {
    	//获取类型信息
    	Class<?> keyClass = key.getClass();
    	if (keyClass != keyType && keyClass.getSuperclass() != keyType)
    		throw new ClassCastException(keyClass + " != " + keyType);
    }

接着通过 int index = key.ordinal() 的方式获取到该枚举实例的顺序值，利用此值作为下标，把值存储在 vals 数组对应下标的元素中即 vals\[index\]，这也是为什么 EnumMap 能维持与枚举实例相同存储顺序的原因，我们发现在对 vals\[\] 中元素进行赋值和返回旧值时分别调用了 maskNull 方法和 unmaskNull 方法：

// 代表NULL值的空对象实例
    private static final Object NULL = new Object() {
    	public int hashCode() {
    		return 0;
    	}
    
    	public String toString() {
    		return "java.util.EnumMap.NULL";
    	}
    };
    
    private Object maskNull(Object value) {
    	// 如果值为空，返回NULL对象，否则返回value
    	return (value == null ? NULL : value);
    }
    
    @SuppressWarnings("unchecked")
    private V unmaskNull(Object value) {
    	// 将NULL对象转换为null值
    	return (V)(value == NULL ? null : value);
    }

由此看来 **EnumMap 还是允许存放 null 值的，但 key 绝对不能为 null。**对于 null 值，EnumMap 进行了特殊处理，将其包装为 NULL 对象，毕竟 vals\[\] 存的是 Object，maskNull 方法和 unmaskNull 方法正是用于 null 的包装和解包装的。这就是 EnumMap 集合的添加过程。下面接着看获取方法：

*  **get 方法**

public V get(Object key) {
    	return (isValidKey(key) ? unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
    }
    
    // 对Key值的有效性和类型信息进行判断
    private boolean isValidKey(Object key) {
    	if (key == null)
    		return false;
    
    	// Cheaper than instanceof Enum followed by getDeclaringClass
    	Class<?> keyClass = key.getClass();
    	return keyClass == keyType || keyClass.getSuperclass() == keyType;
    }

相对应 put 方法，get 方法显示相当简洁，key 有效的话，直接通过 ordinal 方法取索引，然后在值数组 vals 里通过索引获取值返回。remove 方法如下：

*  **remove 方法**

public V remove(Object key) {
    	// 判断key值是否有效
    	if (!isValidKey(key))
    		return null;
    	// 直接获取索引
    	int index = ((Enum<?>)key).ordinal();
    
    	Object oldValue = vals[index];
    	// 对应下标元素值设置为null
    	vals[index] = null;
    	if (oldValue != null)
    		size--;   // 减size
    	return unmaskNull(oldValue);
    }

非常简单，key 值有效，通过 key 获取下标索引值，把 vals\[\] 对应下标值设置为 null，size减一。再查看是否包含某个值：

*  **contains 方法**

// 判断是否包含某value
    public boolean containsValue(Object value) {
    	value = maskNull(value);
    	// 遍历数组实现
    	for (Object val : vals)
    		if (value.equals(val))
    			return true;
    
    	return false;
    }
    
    // 判断是否包含key
    public boolean containsKey(Object key) {
    	return isValidKey(key) && vals[((Enum<?>)key).ordinal()] != null;
    }

判断 value 直接通过遍历数组实现，而判断 key 就更简单了，判断 key 是否有效和对应 vals\[\] 中是否存在该值。这就是 EnumMap 的主要实现原理：**内部有两个数组，长度相同，一个表示所有可能的键(枚举值)，一个表示对应的值，不允许key 为 null，但允许 value 为 null，键都有一个对应的索引，根据索引直接访问和操作其键数组和值数组，由于操作都是数组，因此效率很高。**

# 7、EnumSet #

**EnumSet 是与枚举类型一起使用的专用 Set 集合，EnumSet 中所有元素都必须是枚举类型。**与其它 Set 接口的实现类HashSet/TreeSet(内部都是用对应的 HashMap/TreeMap 实现的)不同的是，**EnumSet 在内部实现是位向量**(稍后分析)，**它是一种极为高效的位运算操作，由于直接存储和操作都是 bit，因此 EnumSet 空间和时间性能都十分可观，足以媲美传统上基于 int 的“位标志”的运算。**

重要的是我们可像操作 Set 集合一般来操作位运算，这样使用代码更简单易懂同时又具备类型安全的优势。注意**EnumSet 不允许使用 null 元素**。试图插入 null 元素将抛出 NullPointerException，但试图测试判断是否存在 null 元素或移除 null 元素则不会抛出异常，与大多数 Collection 实现一样，**EnumSet 不是线程安全的，因此在多线程环境下应该注意数据同步问题。**下面先来简单看看 EnumSet 的使用方式。

## 7.1、EnumSet用法 ##

**创建 EnumSet 并不能使用 new 关键字，因为它是个抽象类，而应该使用其提供的静态工厂方法。**EnumSet 的静态工厂方法比较多，如下：

// 创建一个具有指定元素类型的空EnumSet
    EnumSet<E> noneOf(Class<E> elementType) 
          
    // 创建一个指定元素类型并包含所有枚举值的EnumSet
    <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType)
    
    // 创建一个包括枚举值中指定范围元素的EnumSet
    <E extends Enum<E>> EnumSet<E> range(E from, E to)
    
    // 初始集合包括指定集合的补集
    <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s)
    
    // 创建一个包括参数中所有元素的EnumSet
    <E extends Enum<E>> EnumSet<E> of(E e)
    <E extends Enum<E>> EnumSet<E> of(E e1, E e2)
    <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3)
    <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4)
    <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4, E e5)
    <E extends Enum<E>> EnumSet<E> of(E first, E... rest)
    
    // 创建一个包含参数容器中的所有元素的EnumSet
    <E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E> s)
    <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c)

代码演示如下：

package zju;
    
    import java.util.ArrayList;
    import java.util.EnumSet;
    import java.util.List;
    
    enum Color {
    	GREEN , RED , BLUE , BLACK , YELLOW
    }
    
    
    public class EnumSetDemo {
    
    	public static void main(String[] args){
    
    		// 空集合
    		EnumSet<Color> enumSet = EnumSet.noneOf(Color.class);
    		System.out.println("添加前：" + enumSet.toString());
    		enumSet.add(Color.GREEN);
    		enumSet.add(Color.RED);
    		enumSet.add(Color.BLACK);
    		enumSet.add(Color.BLUE);
    		enumSet.add(Color.YELLOW);
    		System.out.println("添加后：" + enumSet.toString());
    
    		System.out.println("-----------------------------------");
    
    		// 使用allOf创建包含所有枚举类型的enumSet，其内部根据Class对象初始化了所有枚举实例
    		EnumSet<Color> enumSet1 = EnumSet.allOf(Color.class);
    		System.out.println("allOf直接填充："+enumSet1.toString());
    
    		System.out.println("-----------------------------------");
    
    		// 初始集合包括枚举值中指定范围的元素
    		EnumSet<Color> enumSet2 = EnumSet.range(Color.BLACK,Color.YELLOW);
    		System.out.println("指定初始化范围：" + enumSet2.toString());
    
    		System.out.println("-----------------------------------");
    
    		// 指定补集，也就是从全部枚举类型中去除参数集合中的元素，如下去掉上述enumSet2的元素
    		EnumSet<Color> enumSet3 = EnumSet.complementOf(enumSet2);
    		System.out.println("指定补集：" + enumSet3.toString());
    
    		System.out.println("-----------------------------------");
    
    		// 初始化时直接指定元素
    		EnumSet<Color> enumSet4 = EnumSet.of(Color.BLACK);
    		System.out.println("指定Color.BLACK元素：" + enumSet4.toString());
    		EnumSet<Color> enumSet5 = EnumSet.of(Color.BLACK,Color.GREEN);
    		System.out.println("指定Color.BLACK和Color.GREEN元素：" + enumSet5.toString());
    
    		System.out.println("-----------------------------------");
    
    		// 复制enumSet5容器的数据作为初始化数据
    		EnumSet<Color> enumSet6 = EnumSet.copyOf(enumSet5);
    		System.out.println("enumSet6：" + enumSet6.toString());
    
    		System.out.println("-----------------------------------");
    
    		List<Color> list = new ArrayList<Color>();
    		list.add(Color.BLACK);
    		list.add(Color.BLACK);   // 重复元素
    		list.add(Color.RED);
    		list.add(Color.BLUE);
    		System.out.println("list:"+list.toString());
    
    		// 使用copyOf(Collection<E> c)
    		EnumSet enumSet7 = EnumSet.copyOf(list);
    		System.out.println("enumSet7:" + enumSet7.toString());
    
    		/**
    		 输出结果：
    		 添加前：[]
    		 添加后：[GREEN, RED, BLUE, BLACK, YELLOW]
    		 -----------------------------------
    		 allOf直接填充：[GREEN, RED, BLUE, BLACK, YELLOW]
    		 -----------------------------------
    		 指定初始化范围：[BLACK, YELLOW]
    		 -----------------------------------
    		 指定补集：[GREEN, RED, BLUE]
    		 -----------------------------------
    		 指定Color.BLACK元素：[BLACK]
    		 指定Color.BLACK和Color.GREEN元素：[GREEN, BLACK]
    		 -----------------------------------
    		 enumSet6：[GREEN, BLACK]
    		 -----------------------------------
    		 list:[BLACK, BLACK, RED, BLUE]
    		 enumSet7:[RED, BLUE, BLACK]
    		 */
    	}
    
    }

noneOf(Class<E> elementType) 静态方法，主要用于创建一个空的 EnumSet 集合，传递参数 elementType 代表的是枚举类型的类型信息，即Class对象。

EnumSet<E> allOf(Class<E> elementType) 静态方法则是创建一个填充了 elementType 类型所代表的所有枚举实例，奇怪的是 EnumSet 提供了多个重载形式的 of 方法，最后一个接受的的是可变参数，其他重载方法则是固定参数个数，EnumSet 之所以这样设计是因为可变参数的运行效率低一些，所有在参数数据不多的情况下，强烈不建议使用传递参数为可变参数的 of 方法，即EnumSet<E> of(E first, E... rest)。

其他方法就不分析了，看代码演示即可。至于 EnumSet 的操作方法，则与 Set 集合是一样的，可以看 API 即可这也不过多说明。**什么时候使用 EnumSet 比较恰当的，事实上当需要进行位域运算，就可以使用 EnumSet 提到位域**，如下：

public class EnumSetDemo {
    	// 定义位域变量
    	public static final int TYPE_ONE = 1 << 0 ;    // 1
    	public static final int TYPE_TWO = 1 << 1 ;    // 2
    	public static final int TYPE_THREE = 1 << 2 ;  // 4
    	public static final int TYPE_FOUR = 1 << 3 ;   // 8
    	public static void main(String[] args){
    		// 位域运算
    		int type = TYPE_ONE | TYPE_TWO | TYPE_THREE |TYPE_FOUR;
    	}
    }

诸如上述情况，我们都可以将上述的类型定义成枚举然后采用 EnumSet 来装载，进行各种操作，这样不仅不用手动编写太多冗余代码，而且使用 EnumSet 集合进行操作也将使代码更加简洁明了。

enum Type{
    	TYPE_ONE,TYPE_TWO,TYPE_THREE,TYPE_FOUR 
    }
    
    public class EnumSetDemo {
    	public static void main(String[] args){
    		EnumSet set = EnumSet.of(Type.TYPE_ONE,Type.TYPE_FOUR);
    	}
    }

**其实博主认为 EnumSet 最有价值的是其内部实现原理，采用的是位向量，它体现出来的是一种高效的数据处理方式，这点很值得我们去学习它。**

## 7.2、EnumSet 实现原理剖析 ##

关于 EnumSet 实现原理可能会有点烧脑，内部执行几乎都是位运算，博主将尽力使用图片来分析，协助大家理解。

### 7.2.1  理解位向量 ###

在分析 EnumSet 前有必要先了解以下**位向量**，顾名思义位向量就是用一个 bit 位(0或1)标记一个元素的状态，用一组 bit 位表示一个集合的状态，而每个位对应一个元素，每个 bit 位的状态只可能有两种，即 0 或 1。

位向量能表示的元素个数与向量的 bit 位长度有关，如一个 int 类型能表示 32 个元素，而一个 long 类型则可以表示 64 个元素，对于 EnumSet 而言采用的就 long 类型或者 long 类型数组。

比如现在有一个文件中的数据，该文件存储了N = 1000000 个无序的整数，需要把这些整数读取到内存并排序再重新写回文件中，该如何解决？

最简单的方式是用 int 类型来存储每个数，并把其存入到数组(int a\[m\])中，再进行排序，但是这种方式将会导致存储空间异常大，对数据操作起来效率也能成问题，那有没更高效的方式呢？的确是有的，那就是运用位向量，我们知道一个 int 型的数有 4 个字节，也就是 32 位，那么我们可以用 N/32 个 int 型数组来表示这 N 个数：

a[0]表示第1~32个数（0~31）
    a[1]表示第33~64个数（32~63）
    a[2]表示第65~96个数（64~95）
    ...... 以此类推

这样，**每当输入一个数字 m，我们应该先找到该数字在数组的第 ？个元素，也就是 a\[?\]，然后再确定在这个元素的第几个 bit 位，找到后设置为 1，代表存在该数字。**举个例子来说，比如输入 40，那么 40/32 为 1 余 8，则应该将 a\[1\] 元素值的第 9 个 bit 位置为 1(1 的二进制左移 8 位后就是第 9 个位置)，表示该数字存在，40 数字的表示原理图过程如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 1][]

大概明白了位向量表示方式后，上述过程的计算方式，通过以下方式可以计算该数存储在数组的第 ? 个元素和元素中第 ? 个 bit 位置，为了演示方便，我们这里假设整第 ? 个元素中的 ? 为P，余值设置 S：

// m 除以 2^n 则商(P)表示为 m >> n 
    // 等同于 m / 2^5 取整数 即：40 / 32 = 1 ，那么P=1就是数组中第2个元素，即a[1]
    
    // 位操作过程如下，40的二进制
    00000000 00000000 00000000 00101000
    
    // 右移5位即 n=5 ， m >> 5 ，即结果转为10进制就是P=1
    00000000 00000000 00000000 00000001

在这里我们使用的 int 类型，即 32 位，所有 2^5 = 32，因此 n = 5，由此计算出 P的值代表的是数组的第 P 个元素，接着利用下述方式计算出余数（S），以此设置该元素值的第（S+1）个 bit 位为 1：

// m 除以2^n 的余数(S)表示为 m & (2^n-1) 
    // 等同于： m % 2^5 取余数 即：40 % 32 = 8
    
    // m=40的二进制
    00000000 00000000 00000000 00101000
    
    // 2^n-1（31）的二进制
    00000000 00000000 00000000 00011111
    
    // m & (2^n-1) 即40与31进行与操作得出余数 即 S=8
    00000000 00000000 00000000 00001000 
    
    // 下面是将a[1]元素值的第(8+1)个bit设置为1，为什么是(8+1)不是8？因为1左移8位就在第9个bit位了，过程如下：
    
    // 1的二进制如下：
    00000000 00000000 00000000 00000001
    
    // 1 << 8 利用余数8对1进行左移动
    00000000 00000000 00000001 0000000 
    
    // 然后再与a[1]执行或操作后就可以将对应的bit位设置为1
    // a[P] |= 1 << S 见下述java实现的代码

通过上述二进制位运算过程(关于位运算可以看博主的另一篇博文~[java位运算][java])就可以计算出整数部分 P 和余数部分 S，并成功设置 bit 位为 1，现在利用 Java 来实现这个运算过程如下：

// 定义变量
    private int[] a;              // 数组存储元素的数组
    private int BIT_LENGTH = 32;  // 默认使用int类型
    private int P;                // 整数部分
    private int S;                // 余数
    private int MASK =  0x1F;     // 2^5 - 1
    private int SHIFT = 5;        // 2^n SHIFT=n=5 表示2^5=32 即bit位长度32

计算代码：

// 置位操作,添加操作
    public void set(int i){
    	P = i >> SHIFT; // 结果等同  P = i / BIT_LENGTH; 取整数 ①
    	S = i & MASK;   // 结果等同  S = i % BIT_LENGTH; 取余数 ②
    
    	a[P] |= 1 << S;  // 赋值设置该元素bit位为1              ③
    	// 将int型变量j的第k个比特位设置为1， 即j=j|(1<<k),上述3句合并为一句
    	// a[i >> SHIFT ] |= (1 << (i & MASK));                 ④
    }

计算出P和S后，就可以进行赋值了，其中 a\[P\]代表数组中第P个元素，a\[P\] |= 1 << S 整句意思是把a\[P\]元素的第S+1位设置为1，注意从低位到高位设置，即从右到左，①②③合并为④，代码将更佳简洁。当然有添加操作，那么就会有删除操作，删除操作过程与添加类似，只不过删除是把相对应的bit位设置0，代表不存在该数值。

// 置0操作，相当于清除元素
    public void clear(int i){
    	P =  i >> SHIFT; // 计算位于数组中第？个元素 P = i / BIT_LENGTH;
    	S =  i & MASK;   // 计算余数  S = i % BIT_LENGTH;
    	// 把a[P]元素的第S+1个(从低位到高位)bit位设置为0
    	a[P] &= ~(1 << S);
    
    	// 更优写法
    	// 将int型变量j的第k个比特位设置为0，即j= j&~(1<<k)
    	// a[i>>SHIFT] &= ~(1<<(i &MASK));
    }

与添加唯一不同的是，计算出余数S，利用1左移S位，再取反(~)操作，最后进行与(&)操作，即将a\[P\]元素的第S+1个(从低位到高位)bit位设置为0，表示删除该数字，这个计算过程大家可以自行推算一下。这就是位向量表示法的添加和清除方法，然后我们可以利用下述的get方法判断某个bit是否存在某个数字：

// 读取操作，返回1代表该bit位有值，返回0代表该bit位没值
    public int get(int i){
    	// a[i>>SHIFT] & (1<<(i&MASK));
    	P = i >> SHIFT;
    	S = i &  MASK;
    	return Integer.bitCount(a[P] & (1 << S));
    }

其中 Integer.bitCount() 是返回指定 int 值的二进制补码(计算机数字的二进制表示法都是使用补码表示的)表示形式的 1 位的数量。位向量运算整体代码实现如下：

package com.zju;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    
    // 位向量存储数据
    public class BitVetory {
    	private int count;
    	private int[] a;             // 数组
    	private int BIT_LENGTH = 32; // 默认使用int类型
    	private int P;               // 整数部分
    	private int S;               // 余数
    	private int MASK =  0x1F;    // 2^5 - 1
    	private int SHIFT = 5;       // 2^n SHIFT=n=5 表示2^5=32 即bit位长度32
    
    	/**
    	 * 初始化位向量
    	 * @param count
    	 */
    	public BitVetory(int count) {
    		this.count = count;
    		a = new int[(count-1) / BIT_LENGTH + 1];
    		init();
    	}
    
    	/**
    	 * 将数组中元素bit位设置为0
    	 */
    	public void init(){
    		for (int i = 0; i < count; i++) {
    			clear(i);
    		}
    	}
    
    	/**
    	 * 获取排序后的数组
    	 * @return
    	 */
    	public List<Integer> getSortedArray(){
    		List<Integer> sortedArray = new ArrayList<Integer>();
    
    		for (int i = 0; i < count; i++) {
    			if (get(i) == 1) {  // 判断i是否存在
    				sortedArray.add(i);
    			}
    		}
    		return sortedArray;
    	}
    	/**
    	 * 置位操作,设置元素
    	 * @param i
    	 */
    	public void set(int i){
    		P = i >> SHIFT; // P = i / BIT_LENGTH; 取整数
    		S = i & MASK;   // S = i % BIT_LENGTH; 取余数
    		a[P] |= 1 << S;
    
    		// 将int型变量j的第k个比特位设置为1， 即j=j|(1<<k),上述3句合并为一句
    		// a[i >> SHIFT ] |= (1 << (i & MASK));
    	}
    
    	/**
    	 * 置0操作，相当于清除元素
    	 * @param i
    	 */
    	public void clear(int i){
    		P =  i >> SHIFT; // 计算位于数组中第？个元素 P = i / BIT_LENGTH;
    		S =  i & MASK;   // 计算余数  S = i % BIT_LENGTH;
    		a[P] &= ~(1 << S);
    
    		// 更优写法
    		// 将int型变量j的第k个比特位设置为0，即j= j&~(1<<k)
    		// a[i>>SHIFT] &= ~(1<<(i &MASK));
    	}
    
    	/**
    	 * 读取操作，返回1代表该bit位有值，返回0代表该bit位没值
    	 * @param i
    	 * @return
    	 */
    	public int get(int i){
    		//a[i>>SHIFT] & (1<<(i&MASK));
    		P = i >> SHIFT;
    		S = i &  MASK;
    		return Integer.bitCount(a[P] & (1 << S));
    	}
    
    	// 测试
    	public static void main(String[] args) {
    		int count = 25;
    		List<Integer> randoms = getRandomsList(count);
    		System.out.println("排序前：");
    
    		BitVetory bitVetory = new BitVetory(count);
    		for (Integer e : randoms) {
    			System.out.print(e+",");
    			bitVetory.set(e);
    		}
    
    		List<Integer> sortedArray = bitVetory.getSortedArray();
    		System.out.println();
    		System.out.println("排序后：");
    		for (Integer e : sortedArray) {
    			System.out.print(e + ",");
    		}
    
    		/**
    		 输出结果:
    		 排序前：
    		 6,3,20,10,18,15,19,16,13,4,21,22,24,2,14,5,12,7,23,8,1,17,9,11,
    		 排序后：
    		 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
    		 */
    	}
    
    	private static List<Integer> getRandomsList(int count) {
    		Random random = new Random();
    
    		List<Integer> randomsList = new ArrayList<Integer>();
    		while(randomsList.size() < (count - 1)){
    			int element = random.nextInt(count - 1) + 1;//element ∈  [1,count)
    			if (!randomsList.contains(element)) {
    				randomsList.add(element);
    			}
    		}
    		return randomsList;
    	}
    }

### 7.2.2  EnumSet 原理 ###

有前面位向量的分析，对于了解 EnumSet 的实现原理就相对简单些了，**EnumSet 内部使用的位向量实现**的，前面我们说过 EnumSet 是一个抽象类，事实上它存在两个子类，RegularEnumSet 和 JumboEnumSet。

RegularEnumSet 使用一个 long 类型的变量作为位向量，long 类型的位长度是 64，因此可以存储 64 个枚举实例的标志位，一般情况下是够用的了。

而JumboEnumSet 使用一个 long 类型的数组，当枚举个数超过 64 时，就会采用 long 数组的方式存储。先看看EnumSet 内部的数据结构：

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    	implements Cloneable, java.io.Serializable{
      
    	// 表示枚举类型
    	final Class<E> elementType;
    	
    	// 存储该类型信息所表示的所有可能的枚举实例
    	final Enum<?>[] universe;
    	
    	// ..........
    }

EnumSet 中有两个变量，一个 elementType 用于表示枚举的类型信息，universe 是数组类型，存储该类型信息所表示的所有可能的枚举实例，EnumSet 是抽象类，因此具体的实现是由子类完成的，下面看看 `noneOf(Class<E> elementType) `静态构建方法：

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
    	// 根据EnumMap中的一样，获取所有可能的枚举实例
    	Enum<?>[] universe = getUniverse(elementType);
    	if (universe == null)
    		throw new ClassCastException(elementType + " not an enum");
    
    	if (universe.length <= 64)
    		// 枚举个数小于64，创建RegularEnumSet
    		return new RegularEnumSet<>(elementType, universe);
    	else
    		// 否则创建JumboEnumSet
    		return new JumboEnumSet<>(elementType, universe);
    }

从源码可以看出如果枚举值个数小于等于 64，则静态工厂方法中创建的就是 RegularEnumSet，否则大于 64 的话就创建 JumboEnumSet。无论是 RegularEnumSet 还是 JumboEnumSet，其构造函数内部都间接调用了 EnumSet 的构造函数，因此最终的 elementType 和 universe 都传递给了父类 EnumSet 的内部变量。如下：

// RegularEnumSet构造
    RegularEnumSet(Class<E>elementType, Enum<?>[] universe) {
    	super(elementType, universe);
    }
    
    // JumboEnumSet构造
    JumboEnumSet(Class<E>elementType, Enum<?>[] universe) {
    	super(elementType, universe);
    	elements = new long[(universe.length + 63) >>> 6];
    }

在 RegularEnumSet 类和 JumboEnumSet 类中都存在一个 elements 变量，用于记录位向量的操作：

//RegularEnumSet
    class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> {
    	private static final long serialVersionUID = 3411599620347842686L;
    	// 通过long类型的elements记录位向量的操作
    	private long elements = 0L;
    	//.......
    }
    
    //对于JumboEnumSet则是：
    class JumboEnumSet<E extends Enum<E>> extends EnumSet<E> {
    	private static final long serialVersionUID = 334349849919042784L;
    	// 通过long数组类型的elements记录位向量
    	private long elements[];
    	// 表示集合大小
    	private int size = 0;
    
    	//.............
    }

在 RegularEnumSet 中 elements 是一个 long 类型的变量，共有 64 个 bit 位，因此可以记录 64 个枚举常量，当枚举常量的数量超过 64个 时，将使用 JumboEnumSet，elements 在该类中是一个 long 型的数组，每个数组元素都可以存储 64 个枚举常量，这个过程其实与前面位向量的分析是同样的道理，只不过前面使用的是 32 位的 int 类型，这里使用的是 64 位的long 类型罢了。接着我们看看 EnumSet 是如何添加数据的，RegularEnumSet 中的 add 实现如下：

public boolean add(E e) {
    	// 检测是否为枚举类型
    	typeCheck(e);
    	// 记录旧elements
    	long oldElements = elements;
    	// 执行位向量操作，是不是很熟悉？
    	// 数组版：a[i >> SHIFT ] |= (1 << (i & MASK))
    	elements |= (1L << ((Enum)e).ordinal());
    	return elements != oldElements;
    }

关于 elements |= (1L << ((Enum)e).ordinal()); 这句跟我们前面分析位向量操作是相同的原理，只不过前面分析的是数组类型实现，这里用的 long 类型单一变量实现，((Enum)e).ordinal() 通过该语句获取要添加的枚举实例的序号，然后通过 1 左移再与 long 类型的 elements 进行或操作，就可以把对应位置上的 bit 设置为 1 了，也就代表该枚举实例存在。图示演示过程如下，注意 universe 数组在 EnumSet 创建时就初始化并填充了所有可能的枚举实例，而 elements 值的第 n 个 bit 位 1 时代表枚举存在，而获取的则是从 universe 数组中的第 n 个元素值。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 2][]

这就是枚举实例的添加过程和获取原理。而对于 JumboEnumSe t的 add 实现则是如下：

public boolean add(E e) {
        typeCheck(e);
        // 计算ordinal值
        int eOrdinal = e.ordinal();
        int eWordNum = eOrdinal >>> 6;
    
        long oldElements = elements[eWordNum];
        // 与前面分析的位向量相同：a[i >> SHIFT ] |= (1 << (i & MASK))
        elements[eWordNum] |= (1L << eOrdinal);
        boolean result = (elements[eWordNum] != oldElements);
        if (result)
            size++;
        return result;
    }

关于 JumboEnumSet 的 add 实现与 RegularEnumSet 区别是一个是 long 数组类型，一个 long 变量，运算原理相同，数组的位向量运算与前面分析的是相同的，这里不再分析。接着看看如何删除元素：

// RegularEnumSet类实现
    public boolean remove(Object e) {
    	if (e == null)
    		return false;
    	Class eClass = e.getClass();
    	if (eClass != elementType && eClass.getSuperclass() != elementType)
    		return false;
    
    	long oldElements = elements;
    	// 将int型变量j的第k个比特位设置为0，即j= j&~(1<<k)
    	// 数组类型：a[i>>SHIFT] &= ~(1<<(i &MASK));
    
    	elements &= ~(1L << ((Enum)e).ordinal());//long遍历类型操作
    	return elements != oldElements;
    }
    
    
    // JumboEnumSet类的remove实现
    public boolean remove(Object e) {
    	if (e == null)
    		return false;
    	Class<?> eClass = e.getClass();
    	if (eClass != elementType && eClass.getSuperclass() != elementType)
    		return false;
    	int eOrdinal = ((Enum<?>)e).ordinal();
    	int eWordNum = eOrdinal >>> 6;
    
    	long oldElements = elements[eWordNum];
    	// 与a[i>>SHIFT] &= ~(1<<(i &MASK)); 相同
    	elements[eWordNum] &= ~(1L << eOrdinal);
    	boolean result = (elements[eWordNum] != oldElements);
    	if (result)
    		size--;
    	return result;
    }

删除 remove 的实现，跟位向量的清空操作是同样的实现原理，如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 3][]

至于 JumboEnumSet 的实现原理也是类似的，这里不再重复。下面为了简洁起见，我们以 RegularEnumSet 类的实现作为源码分析，毕竟 JumboEnumSet 的内部实现原理可以说跟前面分析过的位向量几乎一样。看看如何判断是否包含某个元素：

public boolean contains(Object e) {
    	if (e == null)
    		return false;
    	Class eClass = e.getClass();
    	if (eClass != elementType && eClass.getSuperclass() != elementType)
    		return false;
    	// 先左移再按&操作
    	return (elements & (1L << ((Enum)e).ordinal())) != 0;
    }
    
    public boolean containsAll(Collection<?> c) {
    	if (!(c instanceof RegularEnumSet))
    		return super.containsAll(c);
    
    	RegularEnumSet<?> es = (RegularEnumSet<?>)c;
    	if (es.elementType != elementType)
    		return es.isEmpty();
    	// elements取反相当于elements补集，再与es.elements进行&操作，如果为0，
    	// 就说明elements补集与es.elements没有交集，也就是es.elements是elements的子集
    	return (es.elements & ~elements) == 0;
    }

对于contains(Object e) 方法，先左移再按位与操作，不为 0，则表示包含该元素，跟位向量的 get 操作实现原理类似，这个比较简单。对于containsAll(Collection<?> c)则可能比较难懂，这里分析一下，elements 变量(long类型)标记EnumSet 集合中已存在元素的 bit 位，如果 bit 位为 1 则说明存在枚举实例，为 0 则不存在，现在执行~elements 操作后 则说明 ~elements 是 elements 的补集，那么只要传递进来的 es.elements 与补集 ~elements 执行 & 操作为 0，那么就可以证明es.elements 与补集 ~elements 没有交集的可能，也就是说 es.elements 只能是 elements 的子集，这样也就可以判断出当前EnumSet 集合中包含传递进来的集合c了，借着下图协助理解：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 4][]

图中，elements代表A，**`es.elements `**代表S，~**`elements `**就是求 A 的补集，`(es.elements &`~`elements) == 0 `就是在验证 A’∩B 是不是空集，即 S 是否为 A 的子集。接着看 retainAll 方法，求两个集合交集：

public boolean retainAll(Collection<?> c) {
    	if (!(c instanceof RegularEnumSet))
    		return super.retainAll(c);
    
    	RegularEnumSet<?> es = (RegularEnumSet<?>)c;
    	if (es.elementType != elementType) {
    		boolean changed = (elements != 0);
    		elements = 0;
    		return changed;
    	}
    
    	long oldElements = elements;
    	// 执行与操作，求交集，比较简单
    	elements &= es.elements;
    	return elements != oldElements;
    }

最后来看看迭代器是如何取值的：

public Iterator<E> iterator() {
    	return new EnumSetIterator<>();
    }
    
    private class EnumSetIterator<E extends Enum<E>> implements Iterator<E> {
    	// 记录elements
    	long unseen;
    
    	// 记录最后一个返回值
    	long lastReturned = 0;
    
    	EnumSetIterator() {
    		unseen = elements;
    	}
    
    	public boolean hasNext() {
    		return unseen != 0;
    	}
    
    	@SuppressWarnings("unchecked")
    	public E next() {
    		if (unseen == 0)
    			throw new NoSuchElementException();
    		// 取值过程，先与本身负执行&操作得出的就是二进制低位开始的第一个1的数值大小
    		lastReturned = unseen & -unseen;
    		// 取值后减去已取得lastReturned
    		unseen -= lastReturned;
    		// 返回在指定 long 值的二进制补码表示形式中最低位（最右边）的 1 位之后的零位的数量
    		return (E) universe[Long.numberOfTrailingZeros(lastReturned)];
    	}
    
    	public void remove() {
    		if (lastReturned == 0)
    			throw new IllegalStateException();
    		elements &= ~lastReturned;
    		lastReturned = 0;
    	}
    }

比较晦涩的应该是：

// 取值过程，先与本身负执行&操作得出的就是二进制低位开始的第一个1的数值大小
    lastReturned = unseen & -unseen; 
    // 取值后减去已取得lastReturned
    unseen -= lastReturned;
    return (E) universe[Long.numberOfTrailingZeros(lastReturned)];

我们通过原理图来协助理解，现在假设集合中已保存所有可能的枚举实例变量，我们需要把它们遍历展示出来，下面的第一个枚举元素的获取过程，显然通过 **unseen & -unseen;** 操作，我们可以获取到二进制低位开始的第一个1的数值，该计算的结果是要么全部都是0，要么就只有一个1，然后赋值给 lastReturned，通过 Long.numberOfTrailingZeros(lastReturned)获取到该 bit 为 1 在 64 位的 long 类型中的位置，即从低位算起的第几个 bit，如图，该 bit 的位置恰好是低位的第 1 个 bit 位置，也就指明了 universe 数组的第一个元素就是要获取的枚举变量。执行 unseen -= lastReturned; 后继续进行第 2 个元素的遍历，依次类推遍历出所有值，这就是 EnumSet 的取值过程，真正存储枚举变量的是 universe 数组，而通过 long 类型变量的 bit 位的 0 或 1 表示存储该枚举变量在 universe 数组的那个位置，这样做的好处是任何操作都是执行 long 类型变量的 bit 位操作，这样执行效率将特别高，毕竟是二进制直接执行，只有最终获取值时才会操作到数组 universe。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 5][]

ok~，到这关于 EnumSet 的实现原理主要部分我们就分析完了，其内部使用位向量，存储结构很简洁，节省空间，大部分操作都是按位运算，直接操作二进制数据，因此效率极高。当然通过前面的分析，我们也掌握位向量的运算原理。好~，关于 Java 枚举，我们暂时聊到这。

[https_blog.csdn.net_javazejian_article_details_71333103]: https://blog.csdn.net/javazejian/article/details/71333103
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70]: /images/20220325/a1b9f7c2e15c4244ac576b9c596d40e2.png
[20190120160225361.png]: /images/20220325/bb8044bc04ea4681abb5098d4239836b.png
[Link 1]: https://www.baidu.com/s?wd=%E8%BD%BB%E8%80%8C%E6%98%93%E4%B8%BE&tn=24004469_oem_dg&rsv_dl=gh_pl_sl_csd
[Java_Class]: https://blog.csdn.net/pcwl1206/article/details/86556091
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 1]: /images/20220325/4aea5330606c460fb99ae75affb76619.png
[java]: http://blog.csdn.net/javazejian/article/details/51181320
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 2]: /images/20220325/8bfc5d18207c42888fa7931efefc888e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 3]: /images/20220325/51c9b437d0e94e448a23948340499ed3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 4]: /images/20220325/7cdfaffe24934b15b06dc4701300191e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bjd2wxMjA2_size_16_color_FFFFFF_t_70 5]: /images/20220325/62994af879c644a4b19ce10a3bf9170f.png