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;
}

//枚舉類(lèi)型，使用關(guān)鍵字enum
enum Day {
 MONDAY, TUESDAY, WEDNESDAY,
 THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

javac EnumDemo.java 
Day.class EnumDemo.class EnumDemo.java

//反編譯Day.class
final class Day extends Enum
{
 //編譯器為我們添加的靜態(tài)的values()方法
 public static Day[] values()
 {
 return (Day[])$VALUES.clone();
 }
 //編譯器為我們添加的靜態(tài)的valueOf()方法，注意間接調(diào)用了Enum也類(lèi)的valueOf方法
 public static Day valueOf(String s)
 {
 return (Day)Enum.valueOf(com/zejian/enumdemo/Day, s);
 }
 //私有構(gòu)造函數(shù)
 private Day(String s, int i)
 {
 super(s, i);
 }
 //前面定義的7種枚舉實(shí)例
 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 
 { 
 //實(shí)例化枚舉實(shí)例
 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
 });
 }
}

public class EnumDemo {

 public static void main(String[] args){

 //創(chuàng)建枚舉數(shù)組
 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("-------------------------------------");
 //通過(guò)compareTo方法比較,實(shí)際上其內(nèi)部是通過(guò)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]));

 //獲取該枚舉對(duì)象的Class對(duì)象引用,當(dāng)然也可以通過(guò)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);
 }
 /**
 執(zhí)行結(jié)果:
 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 Day {
 MONDAY, TUESDAY, WEDNESDAY,
 THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

//實(shí)現(xiàn)了Comparable
public abstract class Enum<E extends Enum<E>>
 implements Comparable<E>, Serializable {

 private final String name; //枚舉字符串名稱(chēng)

 public final String name() {
 return name;
 }

 private final int ordinal;//枚舉順序值

 public final int ordinal() {
 return ordinal;
 }

 //枚舉的構(gòu)造方法，只能由編譯器調(diào)用
 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;//根據(jù)ordinal值比較大小
 }

 @SuppressWarnings("unchecked")
 public final Class<E> getDeclaringClass() {
 //獲取class對(duì)象引用，getClass()是Object的方法
 Class<?> clazz = getClass();
 //獲取父類(lèi)Class對(duì)象引用
 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()獲取到的是一個(gè)map集合，key值就是name值，value則是枚舉變量值 
 //enumConstantDirectory是class對(duì)象內(nèi)部的方法，根據(jù)class對(duì)象獲取一個(gè)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);
 }

 //.....省略其他沒(méi)用的方法
}

//由編譯器調(diào)用
protected Enum(String name, int ordinal) {
 this.name = name;
 this.ordinal = ordinal;
 }

Day[] days2 = Day.values();
System.out.println("day2:"+Arrays.toString(days2));
Day day = Day.valueOf("MONDAY");
System.out.println("day:"+day);

/**
 輸出結(jié)果:
 day2:[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
 day:MONDAY
 */

//正常使用
Day[] ds=Day.values();
//向上轉(zhuǎn)型Enum
Enum e = Day.MONDAY;
//無(wú)法調(diào)用,沒(méi)有此方法
//e.values();

//正常使用
Day[] ds=Day.values();
//向上轉(zhuǎn)型Enum
Enum e = Day.MONDAY;
//無(wú)法調(diào)用,沒(méi)有此方法
//e.values();
//獲取class對(duì)象引用
Class<?> clasz = e.getDeclaringClass();
if(clasz.isEnum()) {
 Day[] dsz = (Day[]) clasz.getEnumConstants();
 System.out.println("dsz:"+Arrays.toString(dsz));
}

/**
 輸出結(jié)果:
 dsz:[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
 */

public enum Day2 {
MONDAY("星期一"),
TUESDAY("星期二"),
WEDNESDAY("星期三"),
THURSDAY("星期四"),
FRIDAY("星期五"),
SATURDAY("星期六"),
SUNDAY("星期日");//記住要用分號(hào)結(jié)束

private String desc;//中文描述

/**
* 私有構(gòu)造,防止被外部調(diào)用
* @param desc
*/
private Day2(String desc){
this.desc=desc;
}

/**
* 定義方法,返回描述,跟常規(guī)類(lèi)的定義沒(méi)區(qū)別
* @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());
}
}

/**
輸出結(jié)果:
name:MONDAY,desc:星期一
name:TUESDAY,desc:星期二
name:WEDNESDAY,desc:星期三
name:THURSDAY,desc:星期四
name:FRIDAY,desc:星期五
name:SATURDAY,desc:星期六
name:SUNDAY,desc:星期日
*/
}

public enum Day2 {
 MONDAY("星期一"),
 TUESDAY("星期二"),
 WEDNESDAY("星期三"),
 THURSDAY("星期四"),
 FRIDAY("星期五"),
 SATURDAY("星期六"),
 SUNDAY("星期日");//記住要用分號(hào)結(jié)束

 private String desc;//中文描述

 /**
 * 私有構(gòu)造,防止被外部調(diào)用
 * @param desc
 */
 private Day2(String desc){
 this.desc=desc;
 }

 /**
 * 覆蓋
 * @return
 */
 @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());
 }
 }

 /**
 輸出結(jié)果:
 name:MONDAY,desc:星期一
 name:TUESDAY,desc:星期二
 name:WEDNESDAY,desc:星期三
 name:THURSDAY,desc:星期四
 name:FRIDAY,desc:星期五
 name:SATURDAY,desc:星期六
 name:SUNDAY,desc:星期日
 */
}

public enum EnumDemo3 {

 FIRST{
 @Override
 public String getInfo() {
  return "FIRST TIME";
 }
 },
 SECOND{
 @Override
 public String getInfo() {
  return "SECOND TIME";
 }
 }

 ;

 /**
 * 定義抽象方法
 * @return
 */
 public abstract String getInfo();

 //測(cè)試
 public static void main(String[] args){
 System.out.println("F:"+EnumDemo3.FIRST.getInfo());
 System.out.println("S:"+EnumDemo3.SECOND.getInfo());
 /**
  輸出結(jié)果:
  F:FIRST TIME
  S:SECOND TIME
  */
 }
}

//無(wú)法通過(guò)編譯,畢竟EnumDemo3.FIRST是個(gè)實(shí)例對(duì)象
 public void text(EnumDemo3.FIRST instance){ }

interface food{
 void eat();
}

interface sport{
 void run();
}

public enum EnumDemo2 implements food ,sport{
 FOOD,
 SPORT,
 ; //分號(hào)分隔

 @Override
 public void eat() {
 System.out.println("eat.....");
 }

 @Override
 public void run() {
 System.out.println("run.....");
 }
}

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;
 }
}

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) {
 //通過(guò)class對(duì)象獲取枚舉實(shí)例
 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;
 }
 }
}

enum Color {GREEN,RED,BLUE}

public class EnumDemo4 {

 public static void printName(Color color){
 switch (color){
  case BLUE: //無(wú)需使用Color進(jìn)行引用
  System.out.println("藍(lán)色");
  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);

 //藍(lán)色
 //紅色
 //綠色
 }
}

/**
 * 餓漢式（基于classloder機(jī)制避免了多線程的同步問(wèn)題）
 */
public class SingletonHungry {

 private static SingletonHungry instance = new SingletonHungry();

 private SingletonHungry() {
 }

 public static SingletonHungry getInstance() {
 return instance;
 }
}

/**
 * Created by wuzejian on 2017/5/9..
 * 懶漢式單例模式（適合多線程安全）
 */
public class SingletonLazy {

 private static volatile SingletonLazy instance;

 private SingletonLazy() {
 }

 public static synchronized SingletonLazy getInstance() {
 if (instance == null) {
  instance = new SingletonLazy();
 }
 return instance;
 }
}

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;
 } 
}

/**
 * Created by wuzejian on 2017/5/9.
 * 靜態(tài)內(nèi)部類(lèi)
 */
public class SingletonInner {
 private static class Holder {
 private static SingletonInner singleton = new SingletonInner();
 }

 private SingletonInner(){}

 public static SingletonInner getSingleton(){
 return Holder.singleton;
 }
}

//測(cè)試?yán)?四種寫(xiě)解決方式雷同)
public class Singleton implements java.io.Serializable { 
 public static Singleton INSTANCE = new Singleton(); 

 protected Singleton() { 
 } 

 //反序列時(shí)直接返回當(dāng)前INSTANCE
 private Object readResolve() { 
  return INSTANCE; 
 } 
}

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 ！");
 }
}

/**
 * 枚舉單利
 */
public enum SingletonEnum {
 INSTANCE;
 private String name;
 public String getName(){
 return name;
 }
 public void setName(String name){
 this.name = name;
 }
}

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);
 }

Map<String, T> enumConstantDirectory() {
 if (enumConstantDirectory == null) {
  //getEnumConstantsShared最終通過(guò)反射調(diào)用枚舉類(lèi)的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存放了當(dāng)前enum類(lèi)的所有枚舉實(shí)例變量，以name為key值
  for (T constant : universe)
  m.put(((Enum<?>)constant).name(), constant);
  enumConstantDirectory = m;
 }
 return enumConstantDirectory;
 }
 private volatile transient Map<String, T> enumConstantDirectory = null;

public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
 //獲取枚舉類(lèi)的構(gòu)造函數(shù)(前面的源碼已分析過(guò))
 Constructor<SingletonEnum> constructor=SingletonEnum.class.getDeclaredConstructor(String.class,int.class);
 constructor.setAccessible(true);
 //創(chuàng)建枚舉
 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)

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;
 }

enum Color {
 GREEN,RED,BLUE,YELLOW
}

import java.util.*;


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());
 }

 /**
 輸出結(jié)果:
 {RED=2, BLUE=3, YELLOW=3, GREEN=2}
 ---------------
 {GREEN=2, RED=2, BLUE=3, YELLOW=3}
 */
}

//創(chuàng)建一個(gè)具有指定鍵類(lèi)型的空枚舉映射。
EnumMap(Class<K> keyType) 
//創(chuàng)建一個(gè)其鍵類(lèi)型與指定枚舉映射相同的枚舉映射，最初包含相同的映射關(guān)系（如果有的話）。 
EnumMap(EnumMap<K,? extends V> m) 
//創(chuàng)建一個(gè)枚舉映射，從指定映射對(duì)其初始化。
EnumMap(Map<K,? extends V> m)

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

public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
 implements java.io.Serializable, Cloneable
{
 //Class對(duì)象引用
 private final Class<K> keyType;

 //存儲(chǔ)Key值的數(shù)組
 private transient K[] keyUniverse;

 //存儲(chǔ)Value值的數(shù)組
 private transient Object[] vals;

 //map的size
 private transient int size = 0;

 //空map
 private static final Enum<?>[] ZERO_LENGTH_ENUM_ARRAY = new Enum<?>[0];

 //構(gòu)造函數(shù)
 public EnumMap(Class<K> keyType) {
 this.keyType = keyType;
 keyUniverse = getKeyUniverse(keyType);
 vals = new Object[keyUniverse.length];
 }

}

//返回枚舉數(shù)組
private static <K extends Enum<K>> K[] getKeyUniverse(Class<K> keyType) {
 //最終調(diào)用到枚舉類(lèi)型的values方法，values方法返回所有可能的枚舉值
 return SharedSecrets.getJavaLangAccess()
     .getEnumConstantsShared(keyType);
 }

public V put(K key, V value) {
 typeCheck(key);//檢測(cè)key的類(lèi)型
 //獲取存放value值得數(shù)組下標(biāo)
 int index = key.ordinal();
 //獲取舊值
 Object oldValue = vals[index];
 //設(shè)置value值
 vals[index] = maskNull(value);
 if (oldValue == null)
  size++;
 return unmaskNull(oldValue);//返回舊值
 }

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

//代表NULL值得空對(duì)象實(shí)例
 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對(duì)象，否則返回value
 return (value == null ? NULL : value);
 }

 @SuppressWarnings("unchecked")
 private V unmaskNull(Object value) {
 //將NULL對(duì)象轉(zhuǎn)換為null值
 return (V)(value == NULL ? null : value);
 }

public V get(Object key) {
 return (isValidKey(key) ?
  unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
 }

 //對(duì)Key值的有效性和類(lèi)型信息進(jìn)行判斷
 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;
 }

public V remove(Object key) {
 //判斷key值是否有效
 if (!isValidKey(key))
  return null;
 //直接獲取索引
 int index = ((Enum<?>)key).ordinal();

 Object oldValue = vals[index];
 //對(duì)應(yīng)下標(biāo)元素值設(shè)置為null
 vals[index] = null;
 if (oldValue != null)
  size--;//減size
 return unmaskNull(oldValue);
 }

判斷是否包含某value
public boolean containsValue(Object value) {
 value = maskNull(value);
 //遍歷數(shù)組實(shí)現(xiàn)
 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;
}

創(chuàng)建一個(gè)具有指定元素類(lèi)型的空EnumSet。
EnumSet<E> noneOf(Class<E> elementType) 
//創(chuàng)建一個(gè)指定元素類(lèi)型并包含所有枚舉值的EnumSet
<E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType)
// 創(chuàng)建一個(gè)包括枚舉值中指定范圍元素的EnumSet
<E extends Enum<E>> EnumSet<E> range(E from, E to)
// 初始集合包括指定集合的補(bǔ)集
<E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s)
// 創(chuàng)建一個(gè)包括參數(shù)中所有元素的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)
//創(chuàng)建一個(gè)包含參數(shù)容器中的所有元素的EnumSet
<E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E> s)
<E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c)

import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;

/**
 * Created by wuzejian on 2017/5/12.
 *
 */
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創(chuàng)建包含所有枚舉類(lèi)型的enumSet，其內(nèi)部根據(jù)Class對(duì)象初始化了所有枚舉實(shí)例
 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("-----------------------------------");

 //指定補(bǔ)集，也就是從全部枚舉類(lèi)型中去除參數(shù)集合中的元素，如下去掉上述enumSet2的元素
 EnumSet<Color> enumSet3= EnumSet.complementOf(enumSet2);
 System.out.println("指定補(bǔ)集："+enumSet3.toString());

 System.out.println("-----------------------------------");

 //初始化時(shí)直接指定元素
 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("-----------------------------------");

 //復(fù)制enumSet5容器的數(shù)據(jù)作為初始化數(shù)據(jù)
 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);//重復(fù)元素
 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());

 /**
  輸出結(jié)果：
  添加前：[]
  添加后：[GREEN, RED, BLUE, BLACK, YELLOW]
  -----------------------------------
  allOf直接填充：[GREEN, RED, BLUE, BLACK, YELLOW]
  -----------------------------------
  指定初始化范圍：[BLACK, YELLOW]
  -----------------------------------
  指定補(bǔ)集：[GREEN, RED, BLUE]
  -----------------------------------
  指定Color.BLACK元素：[BLACK]
  指定Color.BLACK和Color.GREEN元素：[GREEN, BLACK]
  -----------------------------------
  enumSet6：[GREEN, BLACK]
  -----------------------------------
  list:[BLACK, BLACK, RED, BLUE]
  enumSet7:[RED, BLUE, BLACK]
  */
 }

}