Java 如何获得简单的泛型类型名？

我想得到一个方法返回类型的字符串表示，该类型带有类型参数，但没有包名，如“List”

从返回类型的class对象中，我们可以通过

方法获得不带包前缀的简单名称。getReturnType（）.getSimpleName（）

，但不带泛型类型参数。输出：

列表

还可以通过

方法.getGenericReturnType（）.toString（）

获取长格式的泛型类型参数。输出：

java.util.collections.List

但是如何使用泛型类型参数获取简单名称呢

---

例如：

List

而不是

java.util.collections.List

您可以使用以下简单方法浏览类型树：

  static String simpleTypeName(Type t) {
    if (t instanceof ParameterizedType) {
      ParameterizedType p = (ParameterizedType) t;
      return simpleTypeName(p.getRawType())
          + Stream.of(p.getActualTypeArguments())
              // Recurse to handle the type arguments.
              .map(YourClass::simpleTypeName)
              .collect(Collectors.joining(", ", "<", ">"));
    } else if (t instanceof Class) {
      Class<?> c = (Class<?>) t;
      return c.getSimpleName();
    } else {
      // ... handle other Type subtypes.
    }
  }

---

您需要编写一个简单类，该类递归遍历类型并在每个级别上生成简单名称：

class TypeSimpleName {

    private final Type value;

    public TypeSimpleName(Type value) {
        this.value = value;
    }

    public String getName() {
        return getName(value);
    }

    private String getName(Type type) {
        if (type instanceof ParameterizedType) {
            return getParameterizedTypeName((ParameterizedType) type);
        }
        if (type instanceof Class) {
            return getClassSimpleName(type);
        }
        // handle other types if needed

        return type.getTypeName();
    }

    private String getParameterizedTypeName(ParameterizedType type) {
        StringBuilder builder = new StringBuilder();

        builder.append(getName(type.getRawType()));
        Type[] typeArguments = type.getActualTypeArguments();
        if (typeArguments.length > 0) {
            builder.append("<");
            for (int i = 0; i < typeArguments.length; i++) {
                Type arg = typeArguments[i];
                builder.append(getName(arg));
                if (i < typeArguments.length - 1) {
                    builder.append(", ");
                }
            }
            builder.append(">");
        }

        return builder.toString();
    }

    private String getClassSimpleName(Type type) {
        return ((Class) type).getSimpleName();
    }

    @Override
    public String toString() {
        return getName();
    }
} 

classtypesimpleName{
私有最终类型值；
公共类型SimpleName（类型值）{
这个值=值；
}
公共字符串getName（）{
返回getName（值）；
}
私有字符串getName（类型）{
if（类型instanceof ParameterizedType）{
返回getParameteredTypeName（（ParameteredType）类型）；
}
if（类型instanceof Class）{
返回getClassSimpleName（类型）；
}
//如果需要，处理其他类型
返回类型：getTypeName（）；
}
私有字符串GetParameteredTypeName（ParameteredType类型）{
StringBuilder=新的StringBuilder（）；
append（getName（type.getRawType（））；
Type[]typeArguments=Type.getActualTypeArguments（）；
如果（typeArguments.length>0）{
生成器。追加（“”）；
}
返回builder.toString（）；
}
私有字符串getClassSimpleName（类型）{
返回（（类）类型）.getSimpleName（）；
}
@凌驾
公共字符串toString（）{
返回getName（）；
}
} 

如何使用它：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.springframework.util.ReflectionUtils;

public class Test {

    public static void main(String[] args) {
        System.out.println(getReturnTypeName("getList"));
        System.out.println(getReturnTypeName("getListList"));
        System.out.println(getReturnTypeName("getObj"));
        System.out.println(getReturnTypeName("getMapMap"));
    }

    private static String getReturnTypeName(String method) {
        Type returnType = ReflectionUtils.findMethod(Test.class, method).getGenericReturnType();

        return new TypeSimpleName(returnType).getName();
    }

    public List<String> getList() {
        return null;
    }

    public List<List<String>> getListList() {
        return null;
    }

    public Integer getObj() {
        return 1;
    }

    public Map<String, Map<Integer, BigDecimal>> getMapMap() {
        return null;
    }
}

import java.lang.reflect.ParameterizedType；
导入java.lang.reflect.Type；
导入java.math.BigDecimal；
导入java.util.Collections；
导入java.util.List；
导入java.util.Map；
导入org.springframework.util.ReflectionUtils；
公开课考试{
公共静态void main（字符串[]args）{
System.out.println（getReturnTypeName（“getList”）；
System.out.println（getReturnTypeName（“getListList”）；
System.out.println（getReturnTypeName（“getObj”）；
System.out.println（getReturnTypeName（“getMapMap”）；
}
私有静态字符串getReturnTypeName（字符串方法）{
类型returnType=ReflectionUtils.findMethod（Test.class，method）.getGenericReturnType（）；
返回新的TypeSimpleName（returnType）.getName（）；
}
公共列表getList（）{
返回null；
}
公共列表getListList（）{
返回null；
}
公共整数getObj（）{
返回1；
}
公共地图getMapMap（）{
返回null；
}
}

以上代码打印：

List<String>
List<List<String>>
Integer
Map<String, Map<Integer, BigDecimal>>

列表
列表
整数
地图

您可以将其按“.”（点）拆分并读取最后一个索引。有一个方法getSimpleName（）尝试+Warn:java.util.String与com.anees.String相同lexically@MohamedAneesA，但作者故意不希望有包，所以这应该不是问题。@MohamedAneesA您现在可以在这里删除您的评论：）

List<String>
List<List<String>>
Integer
Map<String, Map<Integer, BigDecimal>>