java.lang.reflect.TypeReference不存在

确实，Java标准库中没有 `TypeReference` 类。但是，它是一些第三方库（如 Jackson JSON库）中的一个实用类。
通过使用 `TypeReference` 类，可以在运行时保留泛型类型信息，而不是在编译时丢失。这对于处理复杂的泛型类型非常有用。

以下是一个使用 `TypeReference` 的示例代码：

ObjectMapper mapper = new ObjectMapper();
TypeReference<List<String>> typeRef = new TypeReference<List<String>>() {};
List<String> list = mapper.readValue(jsonString, typeRef);

在上面的示例中，我们使用 `TypeReference` 来指定我们要将JSON字符串转换为哪种类型的对象。这里我们指定了一个 `List<String>` 类型的对象。使用 `TypeReference` 可以保留泛型类型信息，确保我们得到正确类型的对象。

相关问题

java.lang.reflect.TypeReference

`java.lang.reflect.TypeReference`是Java语言中的一个泛型类，它用于获取泛型类型的具体类型。通过继承`TypeReference`类并传递泛型类型参数，可以获取这个泛型类型的具体类型，从而进行一些类型转换等操作。例如，以下是一个使用`TypeReference`获取`List<String>`具体类型的示例：

public class StringList extends TypeReference<List<String>> {}

Type type = new StringList().getType();

在上述示例中，我们定义了一个`StringList`类，它继承自`TypeReference<List<String>>`，这样我们就可以通过`StringList`实例获取`List<String>`类型的具体类型。在`StringList`类中通过`getType()`方法获取到了`List<String>`的具体类型`java.util.List<java.lang.String>`。

Java中 java.lang.reflect.Type 转换成java.lang.Class

在Java中，`java.lang.reflect.Type`和`java.lang.Class`是两个不同的类型，它们分别表示不同的概念。`java.lang.reflect.Type`表示Java中的类型，可以是基本类型、类、接口、数组、泛型等；而`java.lang.Class`表示类的定义，包括类的名称、方法、属性等信息。

如果需要将`java.lang.reflect.Type`转换为`java.lang.Class`，可以通过以下方式实现：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class TypeToClassDemo {
    public static void main(String[] args) {
        // 获取一个泛型类型
        Type type = new TypeReference<String>() {}.getType();

        // 将泛型类型转换为Class
        Class<?> clazz = getClass(type);

        System.out.println(clazz.getName()); // 输出: java.lang.String
    }

    public static Class<?> getClass(Type type) {
        if (type instanceof Class) { // 如果是Class类型，则直接返回
            return (Class<?>) type;
        } else if (type instanceof ParameterizedType) { // 如果是ParameterizedType类型，则获取原始类型
            ParameterizedType parameterizedType = (ParameterizedType) type;
            return (Class<?>) parameterizedType.getRawType();
        } else { // 如果是其他类型，则抛出异常
            throw new IllegalArgumentException("Unsupported type: " + type);
        }
    }

    // 定义一个泛型类型引用
    private static abstract class TypeReference<T> {
        Type getType() {
            Type superClass = getClass().getGenericSuperclass();
            if (superClass instanceof Class) {
                throw new IllegalArgumentException("Missing type parameter.");
            }
            ParameterizedType parameterized = (ParameterizedType) superClass;
            return parameterized.getActualTypeArguments()[0];
        }
    }
}

在上面的代码中，我们首先定义了一个泛型类型`TypeReference<T>`，然后通过`getType()`方法获取泛型类型。接着，我们使用`getClass()`方法将泛型类型转换为`Class`类型。在`getClass()`方法中，我们判断了类型是否为`Class`和`ParameterizedType`，并分别进行了处理。最后，我们就成功地将`java.lang.reflect.Type`类型转换为了`java.lang.Class`类型。