所有知識體系文章，GitHub已收錄，歡迎Star！再次感謝，愿你早日進入大廠！
GitHub地址： https://github.com/Ziphtracks/JavaLearningmanual
深入理解Java列舉
一、什么是列舉
1.1 什么是列舉？
至于列舉，我們先拿生活中的列舉來入手，然后再引申Java中的列舉，其實它們的意義很相似，
談到生活中的列舉，假如我們在玩擲骰子的游戲，在我們手中有兩個骰子，要求擲出兩個骰子的點數和必須大于6的概率，那么在此情此景，我們就需要使用列舉法一一列舉出骰子點數的所有可能，然后根據列舉出來的可能，求出概率，
可能有的小伙伴發現，這就是數學啊？這就是數學中的概率學和統計學，對，我們的列舉法就是常用于概率統計中的，
1.2 Java中的列舉類
Java 5.0引入了列舉，列舉限制變數只能是預先設定好的值，使用列舉可以減少代碼中的 bug，方便很多場景使用，
二、Java列舉的語法
列舉類中的宣告
1訪問修辭符 enum 列舉名 {
2 列舉成員,
3 列舉成員,
4 ...
5};
class類中列舉的宣告
1訪問修飾符 class 類名 {
2 enum 列舉名 {
3 列舉成員,
4 列舉成員,
5 ...
6 }
7}
三、Java列舉類的使用規則和應用場景
3.1 Java列舉類的使用規則
至于列舉你也有所了解了，Java中的列舉也是一樣的，而Java中列舉類的使用，也有特定的規則和場景，如果你看了以下的規則不明白的話，沒有關系，繼續向下學你就會明白，因為我在下面都會有講解到這些規則，如下幾個規則：
- 類的物件是確定的有限個數，
- 當需要定義一組常量時，建議使用列舉，
- 如果列舉類中只有一個物件，則可以作為單例模式的實作方法，
- 列舉類不能被繼承
- 列舉類不能被單獨的new創建物件
- 列舉類中的列舉成員是用`,`隔開的，多個列舉成員之間用`_`隔開
- 如果列舉類中的只有一個或多個列舉成員，其他什么都沒有，我們在用`,`隔開的同時，最后可以省略`;`結束符，
注意： 如果關于列舉單例設計模式不太了解的小伙伴可以參考深度學習單例設計模式一文，你肯定會有意想不到識訓，請相信我！
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（死亡）
- 等等……
四、列舉類的基本使用步驟決議
那我們就解釋以下這兩個規則，我們在上述中已經了解了列舉的作用，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.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類，那么，我們稍后就來就看看這個類中到底寫了些什么方法，
六、Enum常用方法的使用
6.1 Enum中的所有方法
關于Enum類中的所有方法我以表格的方式列舉出來！
| 回傳值 | 方法 | 描述 |
|---|---|---|
| String | name() | 獲取列舉成員的名稱 |
| static |
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
它的原始碼是怎么做的呢？那我們進入查看一下，
其中，前面的操作都是在判斷比較的雙方是否是一個列舉類，如果不是的話就拋出例外，如果為列舉類的話，就直接將次序數做了相減操作并回傳，
七、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 |
allOf(Class<E> elementType) | 創建一個包含指定元素型別的所有元素的列舉 set， |
| EnumSet<E> | clone() | 回傳一個set集合， |
| static |
complementOf(EnumSet<E> s) | 創建一個其元素型別與指定列舉set相同的set集合（新集合中包含原集合所不包含的列舉成員） |
| static |
copyOf(EnumSet<E> s) | 創建一個其元素型別與指定列舉 set 相同的列舉 set集合（新集合中包含與原集合相同的列舉成員） |
| static |
copyOf(Collection<E> s) | 創建一個從指定 collection 初始化的列舉 set |
| static |
noneOf(Class<E> elementType) | 創建一個具有指定元素型別的空列舉 set |
| static |
range(E from, E to) | 創建一個最初包含由兩個指定端點所定義范圍內的所有元素的列舉 set， |
| static |
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}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/168601.html
標籤：Java
上一篇：注解和反射的簡單學習
下一篇：Java筆記：陣列，例外，泛型