欧博会员开户:秒懂系列,超详细Java枚举教程!!!

时间:4个月前   阅读:32

所有知识系统文章,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}
image-20200608151052517

虽然,我们领会了枚举类中的基本使用,然则我们在语法中还先容了一种在类中界说的枚举。正好,在此也演示一下。如下:

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方式,即可见工具内的内容。

image-20200608160220000

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 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
image-20200608173858862

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}

效果为:

image-20200608175529079

其源码就是返回了一个从0最先int类型的值,从源码中也可以看出最大值是int取值局限的最大值。如下:

image-20200608180839568

6.6 compareTo

compareTo方式信赖我们已经是很熟悉了。其作用就是用来对照的。然则在枚举类中它对照的是什么呢?实际上compareTo方式对照的是两个枚举成员的顺序数,并返回顺序相减后的效果。

首先,我们要知道SUMMER的顺序数为1,WINTER的顺序数为3。当使用前者对照后者,打印的效果是前者与后者相减后的差值,即1-3=-2

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

它的源码是怎么做的呢?那我们进入查看一下。

其中,前面的操作都是在判断对照的双方是否是一个枚举类,若是不是的话就抛出异常。若是为枚举类的话,就直接将顺序数做了相减操作并返回。

image-20200608180532795

七、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}
image-20200608194649335

八 枚举类聚集

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

欧博网址

www.dongfangculture.com欢迎进入欧博网址(Allbet Gaming),欧博网址开放会员注册、代理开户、电脑客户端下载、苹果安卓下载等业务。

上一篇:欧博官网:无论是伉俪照样情人,对方自动告诉你这些,不是深爱,而是计划脱离你了

下一篇:欧博allbet注册:米利托:人们对穆帅和国米评价片面 他比瓜帅更强