【Java】枚举类转换封装

最新推荐文章于 2025-03-11 08:52:29 发布
最新推荐文章于 2025-03-11 08:52:29 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41934478/article/details/109092356
版权
本文介绍了用于K-V模式枚举转换的`BaseEnum`接口，提供获取枚举值、键的静态方法。此外，还详细阐述了`EnumUtils`工具类，用于根据枚举的特定字段值查找枚举实例，支持设置忽略大小写和自定义字段名。文章通过示例展示了如何使用这两个工具类进行枚举操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1 K，V枚举转换器

当枚举为K，V模式的时候，通过K，V获取对应的枚举对象需要继承BaseEnum


import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public interface BaseEnum<K, V> {

    K getKey();

    V getValue();

    static <K, V, T extends Enum<?> & BaseEnum<K, V>> List<K> getKeysByEnum(Class<T> enumClass) {
        return Arrays.stream(enumClass.getEnumConstants())
                .map(BaseEnum::getKey)
                .collect(Collectors.toList());
    }

    static <K, V, T extends Enum<?> & BaseEnum<K, V>> List<V> getValuesByEnum(Class<T> enumClass) {
        return Arrays.stream(enumClass.getEnumConstants())
                .map(BaseEnum::getValue)
                .collect(Collectors.toList());
    }

    static <K, V, T extends Enum<?> & BaseEnum<K, V>> T getEnumByKey(Class<T> enumClass, K key) {
        return Arrays.stream(enumClass.getEnumConstants())
                .filter(t -> t.getKey().equals(key))
                .findFirst()
                .orElseThrow(() -> new RuntimeException(""));
    }

    static <K, V, T extends Enum<?> & BaseEnum<K, V>> T getEnumByValue(Class<T> enumClass, V value) {
        return Arrays.stream(enumClass.getEnumConstants())
                .filter(t -> t.getValue().equals(value))
                .findFirst()
                .orElseThrow(() -> new RuntimeException(""));
    }

    static <K, V, T extends Enum<?> & BaseEnum<K, V>> V getValueByKey(Class<T> enumClass, K key) {
        return Arrays.stream(enumClass.getEnumConstants())
                .filter(t -> t.getKey().equals(key))
                .findFirst()
                .orElseThrow(() -> new RuntimeException(""))
                .getValue();
    }

    static <K, V, T extends Enum<?> & BaseEnum<K, V>> K getKeyByValue(Class<T> enumClass, V value) {
        return Arrays.stream(enumClass.getEnumConstants())
                .filter(t -> t.getValue().equals(value))
                .findFirst()
                .orElseThrow(() -> new RuntimeException(""))
                .getKey();
    }
}

2 属性与枚举转换器

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class EnumUtils {

    /**
     * 枚举默认名称字段名
     */
    private static final String ENUM_DEFAULT_FIELD_NAME = "name";

    /**
     * 空字符对象的字符串格式
     */
    private static final String NULL_STRING = "null";

    /**
     * 比较枚举唯一值时是否忽略大小写
     */
    private static boolean IGNORE_CASE = true;

    /**
     * 枚举唯一标识的字段名称
     */
    private static String FIELD_NAME = ENUM_DEFAULT_FIELD_NAME;

    /**
     * 这是比较枚举唯一值是是否忽略大小写
     *
     * @param ignoreCase true-忽略；false-不忽略
     */
    public void setIgnoreCase(boolean ignoreCase) {
        EnumUtils.IGNORE_CASE = ignoreCase;
    }

    /**
     * 设置枚举枚举唯一标识字段名称
     *
     * @param fieldName 字段名称
     */
    public void setFieldName(String fieldName) {
        EnumUtils.FIELD_NAME = fieldName;
    }

    /**
     * 获取枚举项列表。<br/>
     * 等同枚举的<code>values()</code>方法。
     *
     * @param enumClass 枚举类类型
     * @param <E>       枚举类类型
     * @return 枚举项列表
     */
    public static <E extends Enum<E>> List<E> getInstances(Class<E> enumClass) {
        E[] enumItemArray = enumClass.getEnumConstants();
        return Arrays.asList(enumItemArray);
    }

    /**
     * 根据指定的任意字段的值标识符来查找对应的枚举项。如果该字段的值标识符支持重复，则可能返回多个枚举项实例。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param fieldName  待查找匹配的字段名称
     * @param <E>        枚举类类型
     * @return 匹配的枚举项列表
     */
    public static <E extends Enum<E>> List<E> getInstances(Class<E> enumClass, String identifier, String fieldName) {
        List<E> enumList = new ArrayList<E>();
        E[] enumItemArray = enumClass.getEnumConstants();
        if (enumItemArray.length == 0) {
            return enumList;
        }
        try {
            for (E enumItem : enumItemArray) {
                Field field = null;
                if (ENUM_DEFAULT_FIELD_NAME.equals(fieldName)) {
                    field = Enum.class.getDeclaredField(fieldName);
                } else {
                    field = enumItem.getClass().getDeclaredField(fieldName);
                }
                if (field == null) {
                    continue;
                }
                /*if (field.isEnumConstant()) {
                    break;
                }*/
                field.setAccessible(true);
                String value = String.valueOf(field.get(enumItem));
                boolean isEquals = (IGNORE_CASE && value.equalsIgnoreCase(identifier)) || value.equals(identifier);
                if (isEquals) {
                    enumList.add(enumItem);
                    continue;
                }
            }
        } catch (Exception e) {
            return enumList;
        }
        return enumList;
    }

    /**
     * 根据指定的全局配置字段[{@value FIELD_NAME}]的值表示来查找对应的枚举项。如果该字段的值标识符支持重复，则可能返回多个枚举项实例。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param <E>        枚举类类型
     * @return 匹配的枚举项列表
     * @see #getInstances(Class, String, String)
     */
    public static <E extends Enum<E>> List<E> getInstances(Class<E> enumClass, String identifier) {
        return getInstances(enumClass, identifier, FIELD_NAME);
    }

    /**
     * 根据指定的任意字段的值标识符来查找对应的枚举项。并返回首个匹配的枚举项，如果没有匹配则返回null。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param fieldName  待查找匹配的字段名称
     * @param <E>        枚举类类型
     * @return 首个匹配的枚举项实例或null
     * @see #getInstances(Class, String, String)
     */
    public static <E extends Enum<E>> E getInstance(Class<E> enumClass, String identifier, String fieldName) {
        List<E> enumItemList = getInstances(enumClass, identifier, fieldName);
        return enumItemList.size() > 0 ? enumItemList.get(0) : null;
    }

    /**
     * 根据指定的全局配置字段[{@value FIELD_NAME}]的值表示来查找对应的枚举项，并返回第一个匹配的枚举项，如果没有匹配则返回null。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param <E>        枚举类类型
     * @return 首个匹配的枚举项实例或null
     * @see #getInstance(Class, String)
     */
    public static <E extends Enum<E>> E getInstance(Class<E> enumClass, String identifier) {
        return getInstance(enumClass, identifier, FIELD_NAME);
    }

    /**
     * 根据指定的任意字段的值标识符来查找对应的枚举项。并返回首个匹配的枚举项，如果没有匹配则返回指定的默认枚举对象。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass    枚举类类型
     * @param identifier   值标识符
     * @param fieldName    待查找匹配的字段名称
     * @param enumInstance 默认返回枚举对象
     * @param <E>          枚举类类型
     * @return 首个匹配的枚举项实例或默认返回枚举对象
     * @see #getInstances(Class, String, String)
     */
    public static <E extends Enum<E>> E getInstanceOrDefault(Class<E> enumClass, String identifier, String fieldName, E enumInstance) {
        List<E> enumItemList = getInstances(enumClass, identifier, fieldName);
        return enumItemList.size() > 0 ? enumItemList.get(0) : enumInstance;
    }

    /**
     * 根据指定的全局配置字段[{@value FIELD_NAME}]的值表示来查找对应的枚举项，并返回第一个匹配的枚举项，如果没有匹配则指定的默认枚举对象。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass    枚举类类型
     * @param identifier   值标识符
     * @param enumInstance 默认返回枚举对象
     * @param <E>          枚举类类型
     * @return 首个匹配的枚举项实例或默认返回枚举对象
     * @see #getInstanceOrDefault(Class, String, String, Enum)
     */
    public static <E extends Enum<E>> E getInstanceOrDefault(Class<E> enumClass, String identifier, E enumInstance) {
        return getInstanceOrDefault(enumClass, identifier, FIELD_NAME, enumInstance);
    }

    /**
     * 判断指定的值标识符是否是一个枚举实例；根据指定的字段进行比较匹配。同时如果给定的值标识为空，指定是否允许忽略。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param fieldName  待查找匹配的字段名称
     * @param ignoreNull 是否忽略空标识符
     * @param <E>        枚举类类型
     * @return 如果忽略空，则传入是空则返回true；如果不忽略空，如果是枚举项则返回true，否则或异常则返回false
     */
    public static <E extends Enum<E>> boolean isEnumInstance(Class<E> enumClass, String identifier, String fieldName, boolean ignoreNull) {
        if (ignoreNull && NULL_STRING.equals(String.valueOf(identifier))) {
            return true;
        }
        try {
            E[] enumItemArray = enumClass.getEnumConstants();
            for (E enumItem : enumItemArray) {
                Field field = null;
                if (ENUM_DEFAULT_FIELD_NAME.equals(fieldName)) {
                    field = Enum.class.getDeclaredField(fieldName);
                } else {
                    field = enumItem.getClass().getDeclaredField(fieldName);
                }
                if (field == null) {
                    return false;
                }
                field.setAccessible(true);
                String value = String.valueOf(field.get(enumItem));
                boolean isEnum = (IGNORE_CASE && value.equalsIgnoreCase(identifier)) || value.equals(identifier);
                if (isEnum) {
                    return true;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return false;
    }

    /**
     * 判断指定的值标识符是否是一个枚举实例；根据默认配置字段{@value FIELD_NAME}进行比较匹配。同时如果给定的值标识为空，指定是否允许忽略。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param ignoreNull 是否忽略空标识符
     * @param <E>        枚举类类型
     * @return 如果忽略空，则传入是空则返回true；如果不忽略空，如果是枚举项则返回true，否则或异常则返回false
     */
    public static <E extends Enum<E>> boolean isEnumInstance(Class<E> enumClass, String identifier, boolean ignoreNull) {
        return isEnumInstance(enumClass, identifier, FIELD_NAME, ignoreNull);
    }

    /**
     * 判断指定的值标识符是否是一个枚举实例；根据指定的字段进行比较匹配,如果输入的值标识符为空则返回true。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param fieldName  待查找匹配的字段名称
     * @param <E>        枚举类类型
     * @return 如果传入是空则返回true；如果不为空，如果是枚举项则返回true，否则或异常则返回false
     */
    public static <E extends Enum<E>> boolean isEnumInstance(Class<E> enumClass, String identifier, String fieldName) {
        return isEnumInstance(enumClass, identifier, fieldName, true);
    }

    /**
     * 判断指定的值标识符是否是一个枚举实例；根据默认配置的字段{@value FIELD_NAME}进行比较匹配,如果输入的值标识符为空则返回true。<br/>
     * 会根据全局配置的是否忽略大小写[{@value IGNORE_CASE}]来进行值的比较。
     *
     * @param enumClass  枚举类类型
     * @param identifier 值标识符
     * @param <E>        枚举类类型
     * @return 如果传入是空则返回true；如果不为空，如果是枚举项则返回true，否则或异常则返回false
     */
    public static <E extends Enum<E>> boolean isEnumInstance(Class<E> enumClass, String identifier) {
        return isEnumInstance(enumClass, identifier, FIELD_NAME, true);
    }



}

3 使用样例

import java.util.List;

public enum TestEnum implements BaseEnum<String, String>{

    A("a","1"),
    B("a","2"),
    C("a","3")
    ;

    private final String key;
    private final String value;

    public static void main(String[] args) {
        // 通用的枚举处理器
        List<TestEnum> instancesByKey = EnumUtils.getInstances(TestEnum.class, "a","key");
        List<TestEnum> instancesByValue = EnumUtils.getInstances(TestEnum.class, "1","value");
        TestEnum instanceByName = EnumUtils.getInstance(TestEnum.class, "a");
        System.out.println(instancesByKey);
        System.out.println(instancesByValue);
        System.out.println(instanceByName);
        // kv处理器
        TestEnum enumByValue = BaseEnum.getEnumByValue(TestEnum.class, "a");
        System.out.println(enumByValue);
    }


    TestEnum(String key, String value) {
        this.key = key;
        this.value = value;
    }


    @Override
    public String getKey() {
        return key;
    }

    @Override
    public String getValue() {
        return value;
    }
}
Java 枚举值的相互转换
2301_79365003的博客
09-13 804
有时候，在处理枚举类型时，我们需要进行枚举值之间的转换。我们希望能够根据枚举常量的名称获取对应的枚举值，或者根据枚举值获取对应的名称。方法返回的是枚举常量的名称字符串，而不是枚举常量的值。因此，在使用该方法时，我们需要注意区分枚举常量的名称和枚举常量的值。因此，在使用该方法时，我们需要确保提供的字符串与枚举常量的名称是一致的。方法，我们可以根据枚举常量的名称获取对应的枚举值；这个方法返回枚举常量的名称。需要注意的是，如果给定的字符串不是有效的枚举常量名称，接下来，我们将介绍两种常见的枚举值相互转换的方法。
java枚举转json
软件老王
07-12 3578
1、背景 java后端的枚举类型，要展示到前端，提供给用户进行下拉选择，java后端需要封装enum为json字符串提供给前端，需要首先将枚举类型转为list，然后再转为json字符串。 2、方案 方案也很简单，使用EnumSet.allOf(TestEnum.class)，将数据获取到再塞到list中就可以了。 代码如下： import com.alibaba.fastjson.JSONObject; import java.util.ArrayList; import java.util.EnumSet
java 枚举 封装操作方法
正怒月神的博客
06-02 3780
前言： 由于刚转java项目，所以对于java语言比较陌生，尤其是lambda和一些诸如（一个java文件只能有一个public class）等等的零散知识点之类。。。 使我觉得就语言的层级来说。.net真的超越java不是一星半点。奈何.net跨平台晚，社区力量也小。 相交枚举而言。真的没有 .net中给枚举添加attrbuite来的方便。.net枚举：http://blog.csdn....
Java基础 | Java枚举（Enum）详解：从入门到实践
最新发布
qq_20236937的博客
03-11 4026
Java基础 | Java枚举（Enum）详解：从入门到实践
java常量数据用枚举封装（一）优雅对接前端
weixin_45121446的博客
05-02 2261
java用枚举类替代常量值，对接前端和入库封装
枚举--用枚举封装一个工具类
weixin_43189971的博客
08-13 840
1
java实用类(枚举,包装)
ckw__xyy的博客
08-03 267
一.枚举概述 枚举是由一组固定的常量组成的类型,使用关键字enum定义. 示例: //关键代码: public enum Week{ MON,TUE,WED,THU,FRI,SAT,SUN } public void doWhat(Week day){ switch(day){ case MON: case TUE: case WED: case THU: case FRI; System.out.pringln("工作日,努力写代码!"); break; case SAT: case
java枚举类自动转换存储数据库
yechuanjiang的博客
12-17 3945
奥利给！ 本来准备下班的，看见公司技术比较好的在学习，起身的屁股又做了回去，希望每一天都学点东西做一个记录吧 今天学得算一个小技巧吧，就是前端穿的某一个值，实现自动转换成你要转换的值存入数据库 大概主要步骤就是1、正常写一个枚举-------封装你转换的值 2、加上一个配置文件 就搞定了 进入正题上代码吧： 实体类 /** *yechuanjiang199@63.com * @author ycj * @data 19:21 */ @TableName("my") @Data public class
Jackson优雅序列化Java枚举类过程解析
09-07
在序列化Java枚举类时，有时我们希望不仅仅是输出枚举的名称，而是包含更多的信息，如枚举的关联代码和描述。本文将深入探讨如何使用Jackson优雅地序列化Java枚举类。 1. 前言 在Java中，枚举类可以用来封装静态...
Java枚举和C枚举的转换——JNI笔记
Zhou2828的博客
04-18 4313
前言 最近在做中间件相关，遇到一个JAVA和C之间枚举值通过JNI传递的问题。我们知道C语言的枚举型是一个集合，其每个枚举成员是一个整型常量；而JAVA的枚举其本质是一个类，继承自Enum类，每个枚举成员是枚举类型常量。他们之间是不同的两种数据类型，不能直接进行转换。Java枚举和C枚举的转换本质是Java枚举类型和int整型的转换。 两种枚举的特点 新创建的枚...
详解SpringMVC 自动封装枚举类的方法
08-30
SpringMVC 自动封装枚举类的方法 SpringMVC 框架提供了强大的自动封装机制，可以将 HTTP 请求参数自动转换为 Java 对象。但是，默认情况下，SpringMVC 无法自动封装枚举类。枚举类是一种特殊的 Java 类，它是一种...
对enum简单的封装
03-18
NULL 博文链接：https://dev118.iteye.com/blog/681646
java枚举类统一封装：银行还款计算公式
一切皆有可能
05-10 364
注：本文仅提供思路，具体实现没有涵盖所有的计算方式，如有需要还请自己实现。 package com.yao.dd.enums; import lombok.extern.slf4j.Slf4j; import java.math.BigDecimal; /** * 还款金额计算： * * 应还本息 * 应还罚息 * 应还费用 * 应还复利 * 总应还 * * 已还本息 * 已还罚息 * 已还费用 * 应还复利 * 总已还 * * 待还本息 * 待还罚息 * 待还费用...
java学习笔记14（封装、枚举、继承、抽象类）
嘘嘘喵的博客
10-19 348
ggonjava 任务1 数组中的最大值 1.在 initializeArray() 方法中： 1.1.创建包含 20 个数字的数组 1.2.从控制台读取 20 个数字并将其放入数组中 2.max(int[] array) 方法必须找出数组元素中的最大值 package zh.codegym.task.task07.task0701; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamR
Java面向对象之封装、枚举和包分析解读
life_boy的博客
08-30 175
Java面向对象之封装、枚举和接口分析解读参考
java实用类（枚举、包装类）
m0_61700943的博客
06-10 436
要想知道什么事包装类，我们首先得知道什么是基本数据类型。那什么是基本数据类型呢？基本数据类型包括整型：byte、short、int、long；浮点型：float、double；字符型：char；布尔型：boolean，共8种。那么包装类又是什么呢？为了使用方便和解决不面向对象的问题。
java SpringBoot自动封装枚举类型的方法
热门推荐
lanqibaoer的专栏
03-15 1万+
package com.**.util; import com.wdletu.travel.constant.Gender; import org.springframework.context.annotation.Configuration; import org.springframework.core.convert.converter.Converter; /** * Creat
java 枚举转换_如何在java中将一个枚举转换为另一个枚举？
weixin_39640520的博客
02-16 790
Chomeh..9我通过实现转换服务将外部xml接口与内部域模型分离.这包括将jaxb生成的代码中的枚举映射到域模型枚举.使用静态EnumMap封装了负责转换的类中转换的关注点.它的凝聚力.@Servicepublic class XmlTransformer {private static final Map xmlSenseToSense;static {xmlSenseToSense = n...
Java反射，枚举讲解
Mylvzi的博客
12-14 1056
枚举是在JDK1.5以后引入的。和之前C语言中学习过的枚举常量类似，都是将一组常量有序组织起来的集合在这之前定义常量的方式使用枚举常量本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了 这个类。直接将枚举类型定义为一个类//拿到枚举实例BLACK//拿到枚举实例RED。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值