【Java 开发实例】Java 枚举的几种常见的用法

废话不多说系列，直接上代码！

（1）用于系统枚举同类常量

核心代码逻辑

1. 根据 msg 获取 code；
2. 根据 code 获取 msg；
3. 根据 code 获取枚举全部信息；
4. 判断是否存在对应的 code ；
5. 判断是否存在对应的 msg；

import org.apache.commons.lang3.StringUtils;
import java.util.Objects;

/**
 * 核销状态枚举类
 */
public enum VerificationStatusEnum {
    /**
     * 待完成
     */
    VERIFICATION_STATUS_NO("0", "待完成"),
    /**
     * 已完成
     */
    VERIFICATION_STATUS_TODO("1", "已完成"),
    /**
     * 部分完成
     */
    VERIFICATION_STATUS_PART("2", "部分完成"),

    ;
    /**
     * 编码
     */
    private String code;
    /**
     * 编码含义
     */
    private String msg;

    VerificationStatusEnum(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public static String getCodeByMsg(String msg) {
        if (Objects.isNull(msg)) {
            return null;
        }
        VerificationStatusEnum[] arr = VerificationStatusEnum.values();
        for (VerificationStatusEnum verificationStatusEnum : arr) {
            if (msg.equals(verificationStatusEnum.getMsg())) {
                return verificationStatusEnum.getCode();
            }
        }
        return null;
    }

    public static String getMsgByCode(String code) {
        if (Objects.isNull(code)) {
            return "";
        }
        VerificationStatusEnum[] arr = VerificationStatusEnum.values();
        for (VerificationStatusEnum verificationStatusEnum : arr) {
            if (code.equals(verificationStatusEnum.getCode())) {
                return verificationStatusEnum.getMsg();
            }
        }
        return "";
    }

    public static VerificationStatusEnum getByCode(String code) {
        if (Objects.isNull(code)) {
            return null;
        }
        VerificationStatusEnum[] arr = VerificationStatusEnum.values();
        for (VerificationStatusEnum verificationStatusEnum : arr) {
            if (code.equals(verificationStatusEnum.getCode())) {
                return verificationStatusEnum;
            }
        }
        return null;
    }

    public static Boolean isHasCode(String code) {
        if (Objects.isNull(code)) {
            return false;
        }
        return !StringUtils.isBlank(getMsgByCode(code));
    }

    public static Boolean isHasMsg(String msg) {
        if (StringUtils.isBlank(msg)) {
            return false;
        }
        return !Objects.isNull(getCodeByMsg(msg));
    }
}

扩展：公共返回状态码

package com.study.module.springbootapilock.enums;

import java.util.Arrays;
import java.util.Objects;

public enum CommonCode {
    /**
     * 成功
     */
    SUCCESS(true, 200, "操作成功!"),
    /**
     * 失败
     */
    FAIL(false, 500, "操作失败！"),
    /**
     * 未找到相关内容
     */
    NO_FIND(false, 500, "未找到相关内容！"),
    ;
    /**
     * 操作是否成功
     */
    private Boolean flag;
    /**
     * 操作代码
     */
    private Integer code;
    /**
     * 提示信息
     */
    private String message;

    CommonCode(Boolean flag, Integer code, String message) {
        this.code = code;
        this.flag = flag;
        this.message = message;
    }

    public static String getMsgByCode(Integer code) {
        if (Objects.isNull(code)) {
            return "";
        }
        CommonCode[] arr = CommonCode.values();
        return Arrays.stream(arr).filter(commonCode -> code.equals(commonCode.getCode())).findFirst().map(CommonCode::getMessage).orElse("");
    }

    public static CommonCode getByCode(Integer code) {
        if (Objects.isNull(code)) {
            return null;
        }
        CommonCode[] arr = CommonCode.values();
        return Arrays.stream(arr).filter(commonCode -> commonCode.getCode().equals(code)).findFirst().orElse(null);
    }

    public Boolean getFlag() {
        return flag;
    }

    public void setFlag(Boolean flag) {
        this.flag = flag;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

（2）用于多线程安全方法存放

相关文章：Java枚举单例模式比DCL和静态单例要好？———反编译分析单例枚举类_砖业洋__-CSDN博客_最好的单例模式

① 双重校验锁单例（DCL）

public class Singleton {
    // volatile 禁止重排序
    private static volatile Singleton singleton;
    // 将构造器私有化
    private Singleton(){}
    // 核心内容 Double Check Lock.（DCL）优点：不仅线程安全，而且延迟加载。
    public static Singleton getInstance(){
        if (singleton == null){
            synchronized (Singleton.class){
                if (singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

相关注意事项：

1. singleton 为何要加上 volatile 关键字？
   1. singleton = new Singleton();  不是一个原子操作；
   2. volatile 主要是限制 JIT 编辑器优化，编译器优化常用方法（将内存变量缓存到寄存器，调整指令顺序充分利用 CPU 指令流水线，常见的是重新排序读写指令。）

② 静态内部类单例

public class Singleton {
    private Singleton(){}

    private static class SingletonInstance {
        private static Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonInstance.singleton;
    }
}

• 与 饿汉式的区别在于：类加载的时候，这里并不会实例化对象，只有调用 getInstance 方法才会实例化对象。
• 与 DCL 优点一样：延迟加载，效率高。

【①DCK】 和 【②静态单例】 都不错。但是他们并不能防止反序列化 和 反射生成多个实例。——更好地写法：枚举单例！

③ 枚举单例

JDK 1.5 添加地 枚举类来实现单例。可以有效的防止 反序列化 和发射破坏。

public enum Singleton {
	INSTANCE,
    
    public void testMethod() {
    	// do something.
        System.out.println("执行了单例类的方法");
    }
}

public class Test {
	public static void main(String[] args) {
    	// 演示如何试用美剧写法的单例类
        Singleton.INSTANCE.testMethod(); 		// 输出“执行了单例类的方法”
        System.out.println(Singleton.INSTANCE); // 输出“INSTANCE”
    }
}

这样写的优点：

1. 不用考虑懒加载 和 线程安全 问题；
2. 线程安全，代码写法简洁；

更多分析 枚举单例 的字节码文件 解析，见【相关文章】

至此，感谢阅读🙏！