程序员scholar
  • Java
  • JavaSE - 基础篇
scholar
2024-02-05
目录

Java枚举

# 前言

Java中的枚举是一种特殊的类，用于存放一组常量，比如一年分为四个季节、车分为机动车和非机动车等。

# 一、枚举类定义

枚举类型使用关键字enum进行修饰，定义一组常量，定义方式如下：

enum famulei{
        /**
         * famulei:程序员书生
         */
        ZHANGSAN,LISI,WANGWU
    }
1
2
3
4
5
6

定义一个名为famulei的枚举类型，其中有三个成员，ZHANGSAN，LISI，WANGWU，枚举成员一般使用大写。

# 二、访问成员

访问枚举类的成员可以直接通过枚举类名对成员进行访问：

System.out.println(famulei.ZHANGSAN);
1

输出结果：

在这里插入图片描述

也可以通过使用valus()，使用索引进行访问：

System.out.println(famulei.values()[1]);
1

输出结果：

在这里插入图片描述

# 三、遍历

枚举类型的遍历可以使用增强型for循环进行遍历，如下：

for (famulei f : famulei.values()) {
            System.out.println(f);
        }
1
2
3

输出结果：

下载 (9)

# 四、在switch（）中使用枚举

枚举类中的常量可以在switch()中使用，例如：

package learning;
import java.util.Arrays;
import java.util.EnumMap;

/**
 * @ClassName: MyEnum
 * @Description: Enum learning
 * @author: wuyimin
 * @date: 2023/9/23 11:53
 */

public class MyEnum {
    enum famulei {
        /**
         * famulei:程序员书生
         */
        ZHANGSAN, LISI, WANGWU;
    }
    public famulei NameChangedEvent(){
        famulei fml = famulei.LISI;
        switch (fml){
            case ZHANGSAN:
                fml= famulei.LISI;
                break;
            case LISI:
                fml=famulei.WANGWU;
                break;
            case WANGWU:
                fml=famulei.ZHANGSAN;
                break;
            default:
                System.out.println("Error!");
        }
        return fml;
    }

    public static void main(String[] args) {
        MyEnum myEnum =new MyEnum();
        System.out.println(myEnum.NameChangedEvent());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

输出结果：

下载 (3)

# 五、方法

# 1.内置方法

Java中枚举类型还提供了很多其他的方法，比如ordinal()、compareTo()、valueOf()以及上述提到的values()等。

# 1.1 ordinal()用于返回成员的索引

//返回成员索引
System.out.println(famulei.LISI.ordinal());
1
2

输出结果：

下载 (5)

# 1.2 compareTo()用于比较枚举类型中两个成员的索引值

//成员索引成员索引
System.out.println(famulei.ZHANGSAN.compareTo(famulei.WANGWU));
1
2

输出结果： 下载 (6)

# 1.3 valueOf()用于返回枚举类型中指定字符串对应的枚举成员，如果不存在则抛出异常

System.out.println("字符串ZHANGSAN对应的枚举成员："+famulei.valueOf("ZHANGSAN"));
1

输出结果：

下载 (8)

但是，如果枚举类型中不存在指定的字符串对应的成员，会抛出IllegalArgumentException异常：

System.out.println("字符串XIAOLIU对应的枚举成员："+famulei.valueOf("XIAOLIU"));
1

下载 (2)

# 1.4 values()方法以数组方式返回枚举类型中的成员

System.out.println("无格式化输出："+famulei.values());
System.out.println("格式化输出："+ Arrays.toString(famulei.values()));
1
2

输出结果：

下载 (1)

该方法返回了数组的地址，可以使用Arrays.toString（)方法进行格式化。

# 2.构造方法

枚举类型既然是一种特殊的类，那么就有自己的构造方法，使用构造方法可以对枚举类的成员进行属性（也许叫属性不太合适）说明。同时能够实现对成员属性的访问。

package learning;
import java.util.Arrays;
import java.util.EnumMap;

/**
 * @ClassName: MyEnum
 * @Description: Enum learning
 * @author: wuyimin
 * @date: 2023/9/23 11:53
 */

public class MyEnum {
    enum famulei {
        /**
         * famulei:程序员书生
         */
        ZHANGSAN("male",20), LISI("male",25), WANGWU("female",30);
        private String sex;
        private int age;
        //构造方法
        famulei(String sex, int age) {
            this.sex=sex;
            this.age=age;
        }
    }

    public static void main(String[] args) {
        System.out.println("LISI's age:"+famulei.LISI.age);
        System.out.println("ZHANGSAN's sex:"+famulei.ZHANGSAN.sex);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

输出结果：

下载 (7)

# 3.自定义方法

可通过自定义方法修改成员属性，例如：

package learning;
import java.util.Arrays;
import java.util.EnumMap;

/**
 * @ClassName: MyEnum
 * @Description: Enum learning
 * @author: wuyimin
 * @date: 2023/9/23 11:53
 */

public class MyEnum {
    enum famulei {
        /**
         * famulei:程序员书生
         */
        ZHANGSAN("male",20), LISI("male",25), WANGWU("female",30);
        private String sex;
        private int age;
        //构造方法
        famulei(String sex, int age) {
            this.sex=sex;
            this.age=age;
        }

        //自定义方法
        public void setSex(String sex){
            this.sex=sex;
        }
        public void setAge(int age){
            this.age=age;
        }
    }

    public static void main(String[] args) {
        System.out.println("ZHANGSAN's sex:"+famulei.ZHANGSAN.sex);
        System.out.println("ZHANGSAN's age:"+famulei.ZHANGSAN.age);
        famulei.ZHANGSAN.setSex("female");
        famulei.ZHANGSAN.setAge(35);
        System.out.println("ZHANGSAN's sex:"+famulei.ZHANGSAN.sex);
        System.out.println("ZHANGSAN's age:"+famulei.ZHANGSAN.age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

输出结果：

下载

# 4.重写方法

上述Arrays.toString（）方法输出枚举类型中的成员，可以对其进行重写，输出每一个成员的属性，例如：

package learning;
import java.util.Arrays;
import java.util.EnumMap;

/**
 * @ClassName: MyEnum
 * @Description: Enum learning
 * @author: wuyimin
 * @date: 2023/9/23 11:53
 */

public class MyEnum {
    enum famulei {
        /**
         * famulei:程序员书生
         */
        ZHANGSAN("male",20), LISI("male",25), WANGWU("female",30);
        private String sex;
        private int age;
        //构造方法
        famulei(String sex, int age) {
            this.sex=sex;
            this.age=age;
        }

        //自定义方法
        public void setSex(String sex){
            this.sex=sex;
        }
        public void setAge(int age){
            this.age=age;
        }
        //重写方法
        @Override
        public String toString(){
            return this.sex+"-"+this.age;
        }

    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(famulei.values()));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

输出结果：

下载 (4)

# 六、枚举工具类

# 1、定义一个EnumItem接口，供每个枚举类实现

public interface EnumItem<V> extends Serializable {
    // 泛型方法，返回枚举项的代码（唯一标识）
    V getCode();

    // 返回枚举项的值（描述信息）
    String getValue();

    // 返回枚举项的名称
    String getName();
}
1
2
3
4
5
6
7
8
9
10

# 2、枚举类SexEnum实现EnumItem接口，并重写方法

public enum SexEnum implements EnumItem<String> {
    // 定义枚举项，实现EnumItem接口，并指定该枚举code的数据类型为String
    MALE("0", "男"),
    FEMALE("1", "女");

    private final String code; // 枚举项的代码
    private final String value; // 枚举项的值

    // 构造方法，初始化code和value
    SexEnum(String code, String value) {
        this.code = code;
        this.value = value;
    }

    @Override
    public String getCode() {
        return code; // 返回代码
    }

    @Override
    public String getValue() {
        return value; // 返回值
    }

    @Override
    public String getName() {
        return name(); // 返回枚举项的名称
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 3、定义枚举工具类EnumUtil

import java.util.*;
import java.util.stream.Collectors;

public class EnumUtil {
    /**
     * 获取所有枚举项
     * @param enumType 枚举类型
     * @param <T> EnumItem泛型
     * @return 枚举项列表
     */
    public static <T extends EnumItem<?>> List<T> getEnumItems(Class<T> enumType) {
        return Arrays.asList(enumType.getEnumConstants());
    }

    /**
     * 获取以code为键，value为值的Map
     * @param enumType 枚举类型
     * @param <V> code的泛型
     * @param <T> EnumItem泛型
     * @return 枚举映射表
     */
    public static <V, T extends EnumItem<V>> Map<V, String> getEnumMapCode(Class<T> enumType) {
        Map<V, String> map = new HashMap<>();
        for (T enumItem : enumType.getEnumConstants()) {
            map.put(enumItem.getCode(), enumItem.getValue());
        }
        return map;
    }

    /**
     * 获取以value为键，code为值的Map
     * @param enumType 枚举类型
     * @param <V> code的泛型
     * @param <T> EnumItem泛型
     * @return 枚举映射表
     */
    public static <V, T extends EnumItem<V>> Map<String, V> getEnumMapValue(Class<T> enumType) {
        Map<String, V> map = new HashMap<>();
        for (T enumItem : enumType.getEnumConstants()) {
            map.put(enumItem.getValue(), enumItem.getCode());
        }
        return map;
    }

    /**
     * 获取枚举所有项的列表，每个项为一个包含code, value, name的Map
     * @param enumType 枚举类型
     * @param <T> EnumItem泛型
     * @return 枚举项的列表
     */
    public static <T extends EnumItem<?>> List<Map<String, Object>> getEnumList(Class<T> enumType) {
        List<Map<String, Object>> list = new ArrayList<>();
        if (!enumType.isEnum()) {
            return new ArrayList<>();
        }
        T[] enums = enumType.getEnumConstants();
        for (T enumItem : enums) {
            Map<String, Object> map = new HashMap<>();
            map.put("code", enumItem.getCode());
            map.put("value", enumItem.getValue());
            map.put("name", enumItem.getName());
            list.add(map);
        }
        return list;
    }

    /**
     * 获取枚举的所有Code值
     * @param enumType 枚举类型
     * @param <T> EnumItem泛型
     * @param <V> code的泛型
     * @return 枚举code值列表
     */
    public static <V, T extends EnumItem<V>> List<V> getEnumCodes(Class<T> enumType) {
        return Arrays.stream(enumType.getEnumConstants()).map(EnumItem::getCode).collect(Collectors.toList());
    }

    /**
     * 获取枚举的所有Value值
     * @param enumType 枚举类型
     * @param <T> EnumItem泛型
     * @return 枚举value值列表
     */
    public static <T extends EnumItem<?>> List<String> getEnumValues(Class<T> enumType) {
        return Arrays.stream(enumType.getEnumConstants()).map(EnumItem::getValue).collect(Collectors.toList());
    }

    /**
     * 根据Code值查询对应的枚举项
     * @param enumType 枚举类型
     * @param code 枚举code
     * @param <T> EnumItem泛型
     * @param <V> code的泛型
     * @return 枚举项
     */
    public static <V, T extends EnumItem<V>> T fromCode(Class<T> enumType, V code) {
        for (T enumItem : enumType.getEnumConstants()) {
            if (Objects.equals(code, enumItem.getCode())) {
                return enumItem;
            }
        }
        return null;
    }

    /**
     * 根据value获取对应的枚举项
     * @param enumType 枚举类型
     * @param value 枚举value
     * @param <T> EnumItem泛型
     * @return 枚举项
     */
    public static <T extends EnumItem<?>> T fromValue(Class<T> enumType, String value) {
        for (T enumItem : enumType.getEnumConstants()) {
            if (Objects.equals(value, enumItem.getValue())) {
                return enumItem;
            }
        }
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

# 4、测试调用

你可以通过以下方式使用EnumUtil工具类来操作SexEnum枚举类：

  1. 获取所有枚举项：使用getEnumItems(Class<T> enumType)方法获取SexEnum的所有枚举项。这个方法返回枚举类中所有定义的枚举项的列表。
  2. 获取枚举项的Code和Value列表：
    • 使用getEnumCodes(Class<T> enumType)方法获取一个包含枚举类中所有项的code值的列表。
    • 使用getEnumValues(Class<T> enumType)方法获取一个包含枚举类中所有项的value值的列表。
  3. 根据Code获取枚举项：使用fromCode(Class<T> enumType, V code)方法根据枚举项的code值查找并返回对应的枚举项。这允许你直接通过code值来访问特定的枚举项。
  4. 根据Value获取枚举项：使用fromValue(Class<T> enumType, String value)方法根据枚举项的value值查找并返回对应的枚举项。这适用于你有一个枚举项的显示值（value）并想要获取其对应的枚举实例的场景。
public class Test01 {
    public static void main(String[] args) {
        // 获取SexEnum的所有枚举项并打印
        List<SexEnum> items = EnumUtil.getEnumItems(SexEnum.class);
        System.out.println("所有枚举项: " + items);

        // 获取并打印SexEnum所有枚举项的code
        System.out.println("枚举的Code列表: " + EnumUtil.getEnumCodes(SexEnum.class));

        // 获取并打印SexEnum所有枚举项的value
        System.out.println("枚举的Value列表: " + EnumUtil.getEnumValues(SexEnum.class));

        // 根据code获取枚举项并打印
        SexEnum maleByCode = EnumUtil.fromCode(SexEnum.class, "0");
        System.out.println("根据code='0'获取的枚举项: " + maleByCode);

        // 根据value获取枚举项并打印
        SexEnum maleByValue = EnumUtil.fromValue(SexEnum.class, "男");
        System.out.println("根据value='男'获取的枚举项: " + maleByValue);

        // 获取并打印以code为键，value为值的枚举映射表
        System.out.println("Code到Value的映射: " + EnumUtil.getEnumMapCode(SexEnum.class));

        // 获取并打印以value为键，code为值的枚举映射表
        System.out.println("Value到Code的映射: " + EnumUtil.getEnumMapValue(SexEnum.class));

        // 获取并打印枚举的所有项的详细列表
        System.out.println("枚举的详细列表: " + EnumUtil.getEnumList(SexEnum.class));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
编辑此页 (opens new window)
上次更新: 2024/12/28, 18:32:08
Java异常机制
Java反射机制

← Java反射机制→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar