秒懂系列，超詳細Java枚舉教程！！！

時間 2020-06-09

標籤系列詳細 java 枚舉教程欄目 Java 简体版

原文原文鏈接

全部知識體系文章，GitHub已收錄，歡迎Star！再次感謝，願你早日進入大廠！java

GitHub地址： https://github.com/Ziphtracks/JavaLearningmanualgit

深刻理解Java枚舉

1、什麼是枚舉

1.1 什麼是枚舉？

至於枚舉，咱們先拿生活中的枚舉來入手，而後再引伸Java中的枚舉，其實它們的意義很類似。github

談到生活中的枚舉，假如咱們在玩擲骰子的遊戲，在咱們手中有兩個骰子，要求擲出兩個骰子的點數和必須大於6的機率，那麼在此情此景，咱們就須要使用枚舉法一一列舉出骰子點數的全部可能，而後根據列舉出來的可能，求出機率。web

可能有的小夥伴發現，這就是數學啊？這就是數學中的機率學和統計學。對，咱們的枚舉法就是經常使用於機率統計中的。spring

1.2 Java中的枚舉類

Java 5.0引入了枚舉，枚舉限制變量只能是預先設定好的值。使用枚舉能夠減小代碼中的 bug，方便不少場景使用。設計模式

2、Java枚舉的語法

枚舉類中的聲明 數組

1訪問修辭符 enum 枚舉名 {
2    枚舉成員,
3    枚舉成員,
4    ...
5};

class類中枚舉的聲明 微信

1訪問修飾符 class 類名 {
2    enum 枚舉名 {
3        枚舉成員,
4        枚舉成員,
5        ...
6    }
7}

3、Java枚舉類的使用規則和應用場景

3.1 Java枚舉類的使用規則

至於枚舉你也有所瞭解了，Java中的枚舉也是同樣的。而Java中枚舉類的使用，也有特定的規則和場景。若是你看了如下的規則不明白的話，沒有關係，繼續向下學你就會明白，由於我在下面都會有講解到這些規則。以下幾個規則：app

類的對象是肯定的有限個數。

當須要定義一組常量時，建議使用枚舉。

若是枚舉類中只有一個對象，則能夠做爲單例模式的實現方法。

枚舉類不能被繼承

枚舉類不能被單獨的new建立對象

枚舉類中的枚舉成員是用`,`隔開的，多個枚舉成員之間用`_`隔開

若是枚舉類中的只有一個或多個枚舉成員，其餘什麼都沒有，咱們在用`,`隔開的同時。最後能夠省略`;`結束符。

注意： 若是關於枚舉單例設計模式不太瞭解的小夥伴能夠參考深度學習單例設計模式一文，你確定會有意想不到收穫，請相信我！ide

3.2 Java枚舉類的應用場景

根據Java中使用枚舉類的規則，有如下幾種場景適合來使用枚舉類，以下：

星期： Monday（星期一）、Tuesday（星期二）、Wednesday（星期三）、Thursday（星期四）、Firday（星期五）、Saturday（星期六）、Sunday（星期日）

性別： Man（男）、Woman（女）

季節： Spring（春天）、Summer（夏天）、Autumn（秋天）、Winter（冬天）

支付方式： Cash（現金）、WeChatPay（微信）、Alipay（支付寶）、BankCard（銀行卡）、CreditCard（信用卡）

訂單狀態： Nonpayment（未付款）、Paid（已付款）、Fulfilled（已配貨）、Delivered（已發貨）、Return（退貨）、Checked（已確認）

線程狀態： Establish（建立）、Ready（就緒）、Run（運行）、Obstruct（阻塞）、Die（死亡）

等等……

4、枚舉類的基本使用步驟解析

那咱們就解釋如下這兩個規則，咱們在上述中已經瞭解了枚舉的做用。Java中枚舉也不例外，也是一一列舉出來方便咱們拿出來一個或多個使用。這有點像咱們的多選框，咱們把須要用到的全部選項內容放在各個多選框後面，當咱們在使用的時候只須要勾選本身須要的勾選框便可，這就表明了咱們須要被選中多選框後面的內容。

那麼，Java中的枚舉類是如何使用呢？

這裏咱們簡單的模擬一個場景，假設你的女友十分的喜歡喝點冷飲或熱奶茶之類的飲品，在生活中也有不少像蜜雪冰城等等這種類型的飲品店。當你爲女友買她愛喝的珍珠奶茶時，服務員會問你，要大杯、中杯仍是小杯的。固然，爲了知足女友，你一般會選擇大杯。這就意味着店內不容許顧客點規則外的飲品。

注意： 若是你是初學者或是不瞭解枚舉類的使用，此基本使用不懂沒有關係，請繼續往下看便可！

因而，我用Java代碼來實現一下，上述場景。

首先，建立枚舉類。分別爲珍珠奶茶添加大、中、小杯杯型。

 1package com.mylifes1110.java;
 2
 3/**
 4 * @ClassName PearlMilkTea
 5 * @Description 爲珍珠奶茶添加三個杯型：大、中、小
 6 * @Author Ziph
 7 * @Date 2020/6/8
 8 * @Since 1.8
 9 */
10public enum PearlMilkTea {
11    //注意：這裏枚舉類中只有枚舉成員,我在此省略了;結束符
12    SMALL, MEDIUM, LARGE
13}

其次，建立珍珠奶茶對象，再有方法來判斷枚舉類中的大、中、小杯。最後打印女友喝哪一個杯型的珍珠奶茶！

 1package com.mylifes1110.test;
 2
 3import com.mylifes1110.java.PearlMilkTea;
 4
 5/**
 6 * @ClassName PearlMilkTeaTest
 7 * @Description 爲女友買哪一個杯型的珍珠奶茶(默認大杯)
 8 * @Author Ziph
 9 * @Date 2020/6/8
10 * @Since 1.8
11 */
12public class PearlMilkTeaTest {
13    public static void main(String[] args) {
14        //建立大杯的珍珠奶茶對象
15        PearlMilkTea pearlMilkTea = PearlMilkTea.LARGE;
16        PearlMilkTeaTest.drinkSize(pearlMilkTea);
17    }
18
19    //判斷爲女友買哪一個杯型的珍珠奶茶
20    public static void drinkSize(PearlMilkTea pearlMilkTea) {
21        if (pearlMilkTea == PearlMilkTea.LARGE) {
22            System.out.println("我爲女友買了一大杯珍珠奶茶！");
23        } else if (pearlMilkTea == PearlMilkTea.MEDIUM) {
24            System.out.println("我爲女友買了一中杯珍珠奶茶！");
25        } else {
26            System.out.println("我爲女友買了一小杯珍珠奶茶！");
27        }
28    }
29}

雖然，咱們瞭解了枚舉類中的基本使用，可是咱們在語法中還介紹了一種在類中定義的枚舉。正好，在此也演示一下。以下：

1public class PearlMilkTea {
2    enum DrinkSize {
3        SMALL,
4        MEDIUM, 
5        LARGE
6    }
7}

若是這樣建立就能夠在class類中去建立enum枚舉類了。想一想前面例子中的代碼其實並不合理，這是爲何呢？由於咱們寫代碼要遵循單一職責原則和見命知意的命名規範。因此，我寫的代碼是在珍珠奶茶的枚舉類中列舉的大、中、小的三種杯型枚舉成員。因此根據規範來說，咱們珍珠奶茶中不能擁有杯型相關的枚舉，畢竟咱們在生活中的這類飲品店中喝的全部飲品種類都有這三種杯型，所以咱們的全部飲品種類中都須要寫一個枚舉類，顯然這是很不合理的。

若是讓它變的更加合理化，咱們就細分飲品種類來建立飲品枚舉類和杯型的枚舉類並分別兩兩適用便可。也許有小夥伴會問我爲何我要說這些合理不合理呢？由於自我感受這是對枚舉類應用的思想鋪墊，因此你品、你細品！

5、自定義枚舉類

5.1 自定義枚舉類步驟

關於第四章枚舉類的基本使用，也許小夥伴們對枚舉的陌生，而並不知道爲何這樣去建立枚舉對象。接下來，我來帶你使用常量來自定義枚舉類，試試是否是那個效果。

既然，上述第三章我舉出了這麼多枚舉類的應用場景，那咱們挑選一個比較經典的春夏秋冬來實現自定義枚舉類。

首先，咱們先建立一個季節類，分別提供屬性、私有構造器、春夏秋冬常量、Getter方法和toString方法，步驟以下：

 1package com.mylifes1110.java;
 2
 3/**
 4 * 自定義季節的枚舉類
 5 */
 6public class Season {
 7    //聲明Season對象的屬性,爲private final修飾
 8    private final String seasonName;
 9
10    //私有化構造器,併爲對象賦值
11    private Season(String seasonName) {
12        this.seasonName = seasonName;
13    }
14
15    //提供當前枚舉的多個對象,爲public static final修飾
16    public static final Season SPRING = new Season("春天");
17    public static final Season SUMMER = new Season("夏天");
18    public static final Season AUTUMN = new Season("秋天");
19    public static final Season WINTER = new Season("冬天");
20
21    //提供外界經過getter方法來獲取枚舉對象的屬性
22    public String getSeasonName() {
23        return seasonName;
24    }
25
26    //重寫toString方法,以便打印出枚舉結果
27    @Override
28    public String toString() {
29        return "Season{" +
30                "seasonName='" + seasonName + '\'' +
31                '}';
32    }
33}

其次，咱們去建立一個測試類，來使用該自定義枚舉類建立對象。由此看來，咱們就能夠根據類名來句點出常量對象了！

 1package com.mylifes1110.test;
 2
 3import com.mylifes1110.java.Season;
 4
 5/**
 6 * 測試類
 7 */
 8public class SeasonTest {
 9    public static void main(String[] args) {
10        Season spring = Season.SPRING;
11        System.out.println(spring);
12    }
13}

最後打印結果是春天的對象，因爲咱們覆蓋了toString方法，便可見對象內的內容。

5.2 使用帶有參枚舉類

若是你在第三章時Java枚舉類的基本使用不明白，估計看完自定義枚舉類也瞭解的大差不差了。可是你有沒有發現咱們自定義枚舉類是使用的有參數的對象呢？那咱們怎樣使用真正的枚舉類來實現有參數的枚舉類呢？繼續看吧那就！

在這裏我將自定義枚舉類改裝了一下，改裝成了enum枚舉類實現的使用有參對象。以下：

 1package com.mylifes1110.java;
 2
 3public enum Season {
 4    SPRING("春天"),
 5    SUMMER("夏天"),
 6    AUTUMN("秋天"),
 7    WINTER("冬天");
 8
 9    private final String seasonName;
10
11    Season1(String seasonName) {
12        this.seasonName = seasonName;
13    }
14
15    public String getSeasonName() {
16        return seasonName;
17    }
18}

不知道你有沒有發現少了點什麼，少的部分其實就是咱們建立常量對象的部分，並且在這個枚舉類中我也沒有去重寫toString方法，至於爲何，下面就告訴你。

注意： 枚舉對象之間用,隔開！

其次，去建立了該枚舉類的測試類，咱們測試如下，並看一下沒有重寫toString方法打印出來的結果。

 1package com.mylifes1110.test;
 2
 3import com.mylifes1110.java.Season;
 4
 5public class Seaso1Test {
 6    public static void main(String[] args) {
 7        Season1 spring = Season.SPRING;
 8        System.out.println(spring);                     //SPRING
 9        System.out.println(spring.getSeasonName());     //春天
10    }
11}

這裏我將打印的結果放在了打印語句後面的註釋中。咱們發現沒有重寫toString方法居然打印出來的是SPRING，這是爲何呢？這應該從咱們的繼承關係中分析，若是繼承的是基類Object的話，沒有重寫toString方法會打印對象地址。那麼咱們就能夠判定，enum枚舉類的父類不是Object。那它的父類是誰呢？咱們能夠藉助來對象來獲取其父類，以下：

1System.out.println(Season.class.getSuperclass());        //class java.lang.Enum

一樣，答案放在了代碼後面的註釋中。咱們發現它默認繼承的是Enum類。那麼，咱們稍後就來就看看這個類中到底寫了些什麼方法。

6、Enum經常使用方法的使用

6.1 Enum中的全部方法

關於Enum類中的全部方法我以表格的方式列舉出來！

返回值	方法	描述
String	name()	獲取枚舉成員的名稱
static T	valueOf(Class<T> enumType, String name)	獲取指定枚舉成員名稱和類型的枚舉成員
String[]	values()	獲取枚舉成員的全部值

int	compareTo(E o)	比較此枚舉與指定對象的順序
int	hashCode()	獲取枚舉成員的哈希值
int	ordinal()	獲取枚舉成員的序數（第一個枚舉成員位置爲0）
String	toString()	返回枚舉成員名稱
Class<E>	getDeclaringClass()	獲取枚舉成員的類對象

6.2 name和toString

關於name方法和toString方法，其實很簡單。name()就是根據枚舉成員來獲取該枚舉成員的字符串名稱。而同String方法也是用來獲取枚舉成員的字符串名稱。雖然做用都是相同的，可是name方法是用final修飾的不能被重寫，而toString是能夠被重寫的。這裏咱們還使用季節的案例來演示，打印結果並放在了代碼後面的註釋中，以下：

1System.out.println(Season.SUMMER.name());            //SUMMER
2System.out.println(Season.SUMMER.toString());        //SUMMER

6.3 valueOf

此方法的做用是傳入一個字符串，而後將它轉換成對應的枚舉成員。這裏傳入的字符串必須與定義的枚舉成員的名稱一致，嚴格區分大小寫。若是傳入的字符串並無找到其對應的枚舉成員對象，就會拋出異常。以下：

1System.out.println(Season.valueOf("WINTER"));            //WINTER
2System.out.println(Season.valueOf("WIN"));                //java.lang.IllegalArgumentException

6.4 values

values方法的名字中就帶有一個s，再加上它的返回值是一個字符串數組。因此咱們就能夠得出它的做用是獲取枚舉成員的全部值，這些值並以數組的形式存儲。

1Season[] seasons = Season.values();
2for (Season season : seasons) {
3    System.out.print(season + " ");
4}

結果爲：

1SPRING SUMMER AUTUMN WINTER

6.5 ordinal

該方法是獲取枚舉成員的序數，其第一個枚舉成員位置爲0。其實，爲了好理解的話，能夠把它看做數組中的索引。數組中的第一個元素位置一樣也是從0開始。那咱們打印一下，看看結果如何，以下：

1//獲取指定枚舉成員的次序
2System.out.println(Season.SUMMER.ordinal());
3
4//獲取全部成員的次序
5Season[] seasons = Season.values();
6for (Season s : seasons) {
7    System.out.println(s + " -> " + s.ordinal());
8}

結果爲：

其源碼就是返回了一個從0開始int類型的值，從源碼中也能夠看出最大值是int取值範圍的最大值。以下：

6.6 compareTo

compareTo方法相信咱們已是很熟悉了。其做用就是用來比較的。可是在枚舉類中它比較的是什麼呢？實際上compareTo方法比較的是兩個枚舉成員的次序數，並返回次序相減後的結果。

首先，咱們要知道SUMMER的次序數爲1，WINTER的次序數爲3。當使用前者比較後者，打印的結果是前者與後者相減後的差值，即1-3=-2

1System.out.println(Season.SUMMER.compareTo(Season.WINTER));            //-2

它的源碼是怎麼作的呢？那咱們進入查看一下。

其中，前面的操做都是在判斷比較的雙方是不是一個枚舉類，若是不是的話就拋出異常。若是爲枚舉類的話，就直接將次序數作了相減操做並返回。

7、Java枚舉的高級特性

7.1 常量

咱們知道，常量是用public static final修飾的。1.5以後有了枚舉，咱們就能夠把相關的常量放在一個枚舉容器中，並且使用枚舉的好處還在於枚舉爲咱們提供了不少便捷的的方法。

示例：

1public enum Season {
2    SPRING, SUMMER, AUTUMN, WINTER
3}

7.2 switch語句

你瞭解的switch語句都支持哪一種類型呢？我這裏說一下，switch語句支持的類型有以下幾種：

基本數據類型： byte、short、char、int

包裝數據類型： Byte、Short、Character、Integer

枚舉類型： Enum

字符串類型： String（jdk7+ 開始支持）

具體枚舉類與switch語句的使用是如何實現呢？枚舉又是如何爲switch語句提供便利的呢？來看一下吧。

 1package com.mylifes1110.java;
 2
 3public class WeekTest {
 4    public static void main(String[] args) {
 5        Week week = Week.MONDAY;
 6        switch (week) {
 7            case MONDAY:
 8                System.out.println("星期一");
 9                break;
10            case TUESDAY:
11                System.out.println("星期二");
12                break;
13            case WEDNESDAY:
14                System.out.println("星期三");
15                break;
16            case THURSDAY:
17                System.out.println("星期四");
18                break;
19            case FRIDAY:
20                System.out.println("星期五");
21                break;
22            case SATURDAY:
23                System.out.println("星期六");
24                break;
25            case SUNDAY:
26                System.out.println("星期日");
27                break;
28            default:
29                System.out.println("null");
30        }
31    }
32}
33
34enum Week {
35    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
36}

7.3 枚舉中定義多個參數與方法

有參枚舉在5.2中我已經作了詳細說明，咱們在定義枚舉時不僅是能夠定義多個參數，還能夠定義其餘的普通方法來使用，而關於普通方法的使用是根據場景的，這裏我就再也不作過多的贅述了。

 1package com.mylifes1110.java;
 2
 3public enum Season {
 4    SPRING("春天"),
 5    SUMMER("夏天"),
 6    AUTUMN("秋天"),
 7    WINTER("冬天");
 8
 9    private final String seasonName;
10
11    public static String getName(int index) {  
12        for (Season s : Season.values()) {  
13            if (c.getIndex() == index) {  
14                return c.name;  
15            }  
16        }  
17        return null;  
18    }
19
20    Season1(String seasonName) {
21        this.seasonName = seasonName;
22    }
23
24    public String getSeasonName() {
25        return seasonName;
26    }
27}

7.4 枚舉類實現接口

雖然枚舉類不能繼承，可是能夠實現接口。如下是一個實現過程。

首先，建立一個接口。

1package com.mylifes1110.inter;
2
3public interface Show {
4    void show();
5}

其次，讓咱們的四季枚舉類實現該接口並重寫方法。

 1package com.mylifes1110.java;
 2
 3import com.mylifes1110.inter.Show;
 4
 5public enum Season implements Show {
 6    SPRING("春天"),
 7    SUMMER("夏天"),
 8    AUTUMN("秋天"),
 9    WINTER("冬天");
10
11    private final String seasonName;
12
13    Season1(String seasonName) {
14        this.seasonName = seasonName;
15    }
16
17    public String getSeasonName() {
18        return seasonName;
19    }
20
21    @Override
22    public void show() {
23        System.out.println("嚮往四季如春");
24    }
25}

最後，當咱們使用每個枚舉類均可以調用show方法，而打印的結果也都是「嚮往四季如春」

1Season.WINTER.show();                //嚮往四季如春

聰明的你我相信發現了這個缺點，咱們無論使用哪個枚舉成員時，調用的show方法都是同一個。因此，咱們在實現接口後，能夠這樣重寫方法，以下：

 1package com.mylifes1110.java;
 2
 3import com.mylifes1110.inter.Show;
 4
 5public enum Season1 implements Show {
 6    SPRING("春天") {
 7        @Override
 8        public void show() {
 9            System.out.println("春天是個踏青的季節");
10        }
11    },
12    SUMMER("夏天") {
13        @Override
14        public void show() {
15            System.out.println("夏天是個炎熱的季節,我要吃冰棍");
16        }
17    },
18    AUTUMN("秋天") {
19        @Override
20        public void show() {
21            System.out.println("秋天還算是涼爽");
22        }
23    },
24    WINTER("冬天") {
25        @Override
26        public void show() {
27            System.out.println("冬天的雪還不錯,就是有點冷");
28        }
29    };
30
31    private final String seasonName;
32
33    Season1(String seasonName) {
34        this.seasonName = seasonName;
35    }
36
37    public String getSeasonName() {
38        return seasonName;
39    }
40}

咱們在枚舉成員的後面加了{}，而重寫的方法能夠寫在各個枚舉成員中，這樣就接觸了上述全部的那個限制。這下，咱們使用哪一個枚舉成員對象調用show方法都是不一樣的。是否是很是NICE？

7.5 使用接口對枚舉分類

使用接口對枚舉分類，咱們須要建立一個接口容器，裏面存放着此接口容器所存放的多個枚舉類，而後將各個枚舉類實現此接口，以這樣的方式可實現對枚舉分類。代碼以下，打印結果放在了代碼後面的註釋中：

 1package com.mylifes1110.inter;
 2
 3public interface Weeks {
 4    //工做日
 5    enum WorkingDay implements Weeks {
 6        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY
 7    }
 8
 9    //雙休日
10    enum Weekend implements Weeks {
11        SATURDAY, SUNDAY
12    }
13}
14
15class WeeksTest {
16    public static void main(String[] args) {
17        System.out.print("雙休日：");
18        for (Weeks.Weekend weekend : Weeks.Weekend.values()) {
19            System.out.print(weekend + " ");        //雙休日：SATURDAY SUNDAY
20        }
21
22        //換行
23        System.out.println();
24
25        System.out.print("工做日：");
26        for (Weeks.WorkingDay workingDay : Weeks.WorkingDay.values()) {
27            System.out.print(workingDay + " ");     //工做日：MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY
28        }
29
30        //換行
31        System.out.println();
32
33        Weeks.WorkingDay friday = Weeks.WorkingDay.FRIDAY;
34        System.out.println("星期五：" + friday);      //星期五：FRIDAY
35    }
36}

八枚舉類集合

8.1 EnumSet集合

關於Set集合，咱們知道其集合中的元素是不重複的。其中的方法有如下幾種：

返回值	方法	描述
static EnumSet<E>	allOf(Class<E> elementType)	建立一個包含指定元素類型的全部元素的枚舉 set。
EnumSet<E>	clone()	返回一個set集合。
static EnumSet<E>	complementOf(EnumSet<E> s)	建立一個其元素類型與指定枚舉set相同的set集合（新集合中包含原集合所不包含的枚舉成員）
static EnumSet<E>	copyOf(EnumSet<E> s)	建立一個其元素類型與指定枚舉 set 相同的枚舉 set集合（新集合中包含與原集合相同的枚舉成員）
static EnumSet<E>	copyOf(Collection<E> s)	建立一個從指定 collection 初始化的枚舉 set
static EnumSet<E>	noneOf(Class<E> elementType)	建立一個具備指定元素類型的空枚舉 set
static EnumSet<E>	range(E from, E to)	建立一個最初包含由兩個指定端點所定義範圍內的全部元素的枚舉 set。

static EnumSet<E>	of	建立一個最初包含指定元素的枚舉 set。注意：能夠指定多個元素，因此在這裏我沒有列舉參數

8.1.1 allOf

allOf方法須要咱們傳入一個枚舉的類對象，它會根據傳入的枚舉類對象生成一個具備該類對象枚舉成員的Set集合。

1//建立一個包含Week全部枚舉元素的Set集合
2EnumSet<Week> weeks = EnumSet.allOf(Week.class);
3System.out.println(weeks);              //[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
4
5//打印Set集合中的元素
6for (Week week1 : weeks) {
7    System.out.print(week1 + " ");      //MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY SATURDAY SUNDAY
8}

8.1.2 clone

clone方法與直接打印枚舉的Set集合結果相同！

1//返回一個Set集合
2System.out.println(weeks.clone());      //[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]

8.1.3 range

上面詳細講過枚舉是有序數的，並且枚舉類中的枚舉成員是秉承着從左向右的順序。因此咱們可使用range方法來建立指定枚舉成員端點的Set集合，也就是說咱們須要傳入枚舉成員的起始與結束去建立一個該擁有該範圍枚舉成員的Set集合。以下：

1//建立一個最初包含由兩個指定端點所定義範圍內的全部元素的枚舉 set。
2System.out.println(EnumSet.range(Week.MONDAY, Week.FRIDAY));        //[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]

8.1.4 complementOf

該方法有點特殊，它根據EnumSet去建立一個新Set集合。而新Set集合中枚舉成員至關於舊Set集合中枚舉成員的取反。

咱們用場景來模擬一下，當前Week枚舉類中有星期一到星期日7個枚舉成員。咱們使用range方法建立一個從星期一到星期五的Set集合（s1），隨後我在將使用complementOf方法根據s1生成新的Set集合（s2），最後打印s2查看集合中的元素就只有星期六和星期日。

注意： 若是咱們的舊Set集合佔據了枚舉類中的全部枚舉成員，在使用complementOf方法生成的新Set集合，新集合中的元素打印後爲空Set，即[]。

1//建立一個其元素類型與指定枚舉set相同的set集合（新集合中包含原集合所不包含的枚舉成員）
2EnumSet<Week> weeks1 = EnumSet.complementOf(weeks);
3System.out.println(weeks1);             //[]
4
5EnumSet<Week> range = EnumSet.range(Week.MONDAY, Week.FRIDAY);
6EnumSet<Week> weeks3 = EnumSet.complementOf(range);
7System.out.println(weeks3);                //[SATURDAY, SUNDAY]

8.1.5 copyOf

copyOf方法與complementOf相反，它建立一個新Set集合。而新Set集合中的枚舉成員與舊Set集合中的枚舉成員相同，這至關於就是Copy（複製功能）。若是你理解了complementOf方法，這個方法對你來講也是沒有挑戰。如下我使用copyOf方法複製了一份weeks，其枚舉成員一個很多。

注意： copyOf方法還有一個能夠複製connection集合來建立Set集合，其connection集合中必須存儲的是枚舉成員。

1//建立一個其元素類型與指定枚舉 set 相同的枚舉 set集合（新集合中包含與原集合相同的枚舉成員）
2EnumSet<Week> weeks2 = EnumSet.copyOf(weeks);
3System.out.println(weeks2);             //[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]

1//複製存儲枚舉成員的HashSet集合
2Set set = new HashSet();
3set.add(Week.MONDAY);
4EnumSet set1 = EnumSet.copyOf(set);
5System.out.println(set1);        //[MONDAY]

8.1.6 of

of方法爲咱們提供了選擇性的便利，咱們能夠挑選任意枚舉成員成爲Set集合的元素。

1//建立一個最初包含指定元素的枚舉 set。
2System.out.println(EnumSet.of(Week.MONDAY,Week.FRIDAY));            //[MONDAY, FRIDAY]

8.1.7 noneOf

傳入一個枚舉的類對象去建立一個空Set集合

1EnumSet<Week> noneOf = EnumSet.noneOf(Week.class);
2System.out.println(noneOf);                     //[]

8.2 EnumMap集合

8.2.1 EnumMap集合的方法列表

關於Map集合，咱們知道它是由鍵和值組成。EnumMap集合與HashMap集合的效率比較來講，EnumMap的效率高些。

關於EnumMap集合的使用與HashMap是一致的，沒有什麼特殊的。至於EnumMap集合的方法，我這裏列舉一下。

返回值	方法	描述
void	clear()	移除全部映射關係。
EnumMap	clone()	返回EnumMap集合。
boolean	containsKey(Object key)	包含此鍵，則返回true
boolean	containsValue(Object value)	包含一個或多個鍵映射到的該指定值，則返回true
Set >	entrySet()	返回映射鍵值關係的Set集合
boolean	equals(Object o)	比較對象與映射的相等關係
V	get(Object key)	獲取指定鍵映射的值，若是沒有，返回null
Set<K>	keySet()	返回全部鍵的Set集合
V	put(K key, V value)	將指定鍵值存儲在EnumMap集合中
void	putAll(Map m)	將全部鍵值對存儲在集合中
V	remove(Object key)	若是存在映射關係，則移除該映射關係
int	size()	返回存在映射關係的數量
Collection<V>	values()	返回此映射中所包含值的 Collection集合

8.2.2 EnumMap集合的基本使用

因爲EnumMap集合與HashMap集合基本類似，這裏我就演示一下基本使用與HashMap不一樣的地方。

EnumMap集合是咱們new出來的對象，建立出來的對象須要傳入一個枚舉的類對象，才返回一個Map集合。Map集合是鍵值對形式存儲，因此咱們在寫EnumMap集合的泛型時，根據需求來寫，若是須要鍵是某枚舉類型，咱們泛型就寫它。若是有枚舉類是值的要求，那就泛型中的值寫枚舉類。鍵值對都要求是枚舉那也是OK的，咱們寫泛型時都寫需求的枚舉類便可。除了建立對象和存儲對象須要指定枚舉類外，其餘的與HashMap基本相同。

以下，我在建立EnumMap集合時執行的Week枚舉類的類對象，泛型的鍵寫的是Week枚舉類，值寫的Integer，這就意味着咱們在put（存儲鍵值對）的時候，鍵須要存儲Week枚舉類中的枚舉成員，值須要存儲Integer數值。

1EnumMap<Week, Integer> map = new EnumMap<>(Week.class);
2map.put(Week.MONDAY, 1);
3map.put(Week.THURSDAY, 4);
4System.out.println(map);            //{MONDAY=1, THURSDAY=4}