修改Func1参数的方法为LambdaUtil#getInstantiatedClass

提供EnumUtil中对lambda进行映射处理

hutool-core/src/main/java/cn/hutool/core/lang/func/LambdaUtil.java

@@ -1,13 +1,15 @@
 package cn.hutool.core.lang.func;
 
-import java.io.Serializable;
-import java.lang.invoke.SerializedLambda;
-
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.lang.SimpleCache;
 import cn.hutool.core.text.CharPool;
+import cn.hutool.core.text.StrPool;
 import cn.hutool.core.util.ClassUtil;
 import cn.hutool.core.util.ReflectUtil;
+import cn.hutool.core.util.StrUtil;
+
+import java.io.Serializable;
+import java.lang.invoke.SerializedLambda;
 
 /**
  * Lambda相关工具类
@@ -55,8 +57,16 @@ public class LambdaUtil {
 		return resolve(func).getImplMethodName();
 	}
 
-	public static <P> Class<P> getImplClass(Func1<P, ?> func) {
+	/**
-		return ClassUtil.loadClass(resolve(func).getImplClass().replace(CharPool.SLASH, CharPool.DOT));
+	 * 获取lambda实现类
+	 *
+	 * @param func lambda
+	 * @param <P>  类型
+	 * @return lambda实现类
+	 */
+	public static <P> Class<P> getInstantiatedClass(Func1<P, ?> func) {
+		String instantiatedMethodType = resolve(func).getInstantiatedMethodType();
+		return ClassUtil.loadClass(StrUtil.replace(StrUtil.sub(instantiatedMethodType, 2, StrUtil.indexOf(instantiatedMethodType, ';')), StrPool.SLASH, StrPool.DOT));
 	}
 
 	/**
@@ -71,6 +81,13 @@ public class LambdaUtil {
 		return resolve(func).getImplMethodName();
 	}
 
+	/**
+	 * 获取lambda实现类
+	 *
+	 * @param func lambda
+	 * @param <R>  类型
+	 * @return lambda实现类
+	 */
 	public static <R> Class<R> getImplClass(Func0<?> func) {
 		return ClassUtil.loadClass(resolve(func).getImplClass().replace(CharPool.SLASH, CharPool.DOT));
 	}

hutool-core/src/main/java/cn/hutool/core/util/EnumUtil.java

@@ -1,13 +1,13 @@
 package cn.hutool.core.util;
 
 import cn.hutool.core.lang.Assert;
+import cn.hutool.core.lang.func.Func1;
+import cn.hutool.core.lang.func.LambdaUtil;
 import cn.hutool.core.map.MapUtil;
 
 import java.lang.reflect.Field;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
+import java.util.function.Function;
-import java.util.List;
-import java.util.Map;
 
 /**
  * 枚举工具类
@@ -210,6 +210,35 @@ public class EnumUtil {
 		return names;
 	}
 
+
+	/**
+	 * 通过 某字段对应值 获取 枚举，获取不到时为 {@code null}
+	 *
+	 * @param condition 条件字段
+	 * @param value     条件字段值
+	 * @param <E>       枚举类型
+	 * @param <C>       字段类型
+	 * @return 对应枚举 ，获取不到时为 {@code null}
+	 */
+	public static <E extends Enum<E>, C> E getBy(Func1<E, C> condition, C value) {
+		return Arrays.stream(LambdaUtil.getInstantiatedClass(condition).getEnumConstants()).filter(e -> condition.callWithRuntimeException(e).equals(value)).findAny().orElse(null);
+	}
+
+	/**
+	 * 通过 某字段对应值 获取 枚举中另一字段值，获取不到时为 {@code null}
+	 *
+	 * @param field     你想要获取的字段
+	 * @param condition 条件字段
+	 * @param value     条件字段值
+	 * @param <E>       枚举类型
+	 * @param <F>       想要获取的字段类型
+	 * @param <C>       条件字段类型
+	 * @return 对应枚举中另一字段值 ，获取不到时为 {@code null}
+	 */
+	public static <E extends Enum<E>, F, C> F getFieldBy(Function<E, F> field, Func1<E, C> condition, C value) {
+		return Arrays.stream(LambdaUtil.getInstantiatedClass(condition).getEnumConstants()).filter(e -> condition.callWithRuntimeException(e).equals(value)).findAny().map(field).orElse(null);
+	}
+
 	/**
 	 * 获取枚举字符串值和枚举对象的Map对应，使用LinkedHashMap保证有序<br>
 	 * 结果中键为枚举名，值为枚举对象

hutool-core/src/test/java/cn/hutool/core/lang/func/LambdaUtilTest.java

@@ -21,9 +21,11 @@ public class LambdaUtilTest {
 
 	@Test
 	public void getImplClassTest() {
-		Class<MyTeacher> aClass = LambdaUtil.getImplClass(MyTeacher::getAge);
+		// 一般用于封装工具类时减少参数使用
+		Class<MyTeacher> aClass = LambdaUtil.getInstantiatedClass(MyTeacher::getAge);
 		Assert.assertEquals(MyTeacher.class, aClass);
 
+		// 一般用于封装工具类时减少参数使用
 		MyTeacher myTeacher = new MyTeacher();
 		Class<MyTeacher> bClass = LambdaUtil.getImplClass(myTeacher::getAge);
 		Assert.assertEquals(MyTeacher.class, bClass);

hutool-core/src/test/java/cn/hutool/core/util/EnumUtilTest.java

@@ -9,7 +9,7 @@ import java.util.Map;
 
 /**
  * EnumUtil单元测试
- * 
+ *
  * @author looly
  *
  */
@@ -20,39 +20,53 @@ public class EnumUtilTest {
 		List<String> names = EnumUtil.getNames(TestEnum.class);
 		Assert.assertEquals(CollUtil.newArrayList("TEST1", "TEST2", "TEST3"), names);
 	}
-	
+
 	@Test
 	public void getFieldValuesTest() {
 		List<Object> types = EnumUtil.getFieldValues(TestEnum.class, "type");
 		Assert.assertEquals(CollUtil.newArrayList("type1", "type2", "type3"), types);
 	}
-	
+
 	@Test
 	public void getFieldNamesTest() {
 		List<String> names = EnumUtil.getFieldNames(TestEnum.class);
 		Assert.assertTrue(names.contains("type"));
 		Assert.assertTrue(names.contains("name"));
 	}
-	
+
+	@Test
+	public void getByTest() {
+		// 枚举中字段互相映射使用
+		TestEnum testEnum = EnumUtil.getBy(TestEnum::getType, "type2");
+		Assert.assertEquals("TEST2", testEnum.name());
+	}
+
+	@Test
+	public void getFieldByTest() {
+		// 枚举中字段互相映射使用
+		String type = EnumUtil.getFieldBy(TestEnum::getType, TestEnum::ordinal, 1);
+		Assert.assertEquals("type2", type);
+	}
+
 	@Test
 	public void likeValueOfTest() {
 		TestEnum value = EnumUtil.likeValueOf(TestEnum.class, "type2");
 		Assert.assertEquals(TestEnum.TEST2, value);
 	}
-	
+
 	@Test
 	public void getEnumMapTest() {
 		Map<String,TestEnum> enumMap = EnumUtil.getEnumMap(TestEnum.class);
 		Assert.assertEquals(TestEnum.TEST1, enumMap.get("TEST1"));
 	}
-	
+
 	@Test
 	public void getNameFieldMapTest() {
 		Map<String, Object> enumMap = EnumUtil.getNameFieldMap(TestEnum.class, "type");
 		assert enumMap != null;
 		Assert.assertEquals("type1", enumMap.get("TEST1"));
 	}
-	
+
 	public enum TestEnum{
 		TEST1("type1"), TEST2("type2"), TEST3("type3");
 
@@ -62,11 +76,11 @@ public class EnumUtilTest {
 
 		private final String type;
 		private String name;
-		
+
 		public String getType() {
 			return this.type;
 		}
-		
+
 		public String getName() {
 			return this.name;
 		}