Java中如何基于类名实现List<Object>到泛型List的动态转换？

Great question! Let's go through some practical alternatives to dynamically convert your List<Object> into a generic List<T> where T is defined by the fully qualified class name passed in as feedName. Here are a few solid approaches you can implement:

1. Use Guava's TypeToken for Type-Safe Generic List Creation #

If you’re already using Guava in your project, its TypeToken solves Java’s type erasure problem by capturing generic types at runtime. This lets you create a type-safe list without unsafe casts:

import com.google.common.reflect.TypeToken;
import java.util.ArrayList;
import java.util.List;

public Event convertModelToEvent(List<Object> reportingObject, String feedName) throws ClassNotFoundException {
    Event event = new Event();
    event.setHeaderReference(new HeaderReference());
    
    Class<?> targetClass = Class.forName(feedName);
    // Capture the generic List<targetClass> type
    TypeToken<List<?>> listType = new TypeToken<List<?>>() {}
            .where(new TypeToken<?>() {}, targetClass);
    
    // Build a type-safe list by casting each element explicitly
    List<?> typedList = new ArrayList<>(reportingObject.size());
    for (Object obj : reportingObject) {
        typedList.add(targetClass.cast(obj));
    }
    
    event.setPayload(new Payload(typedList));
    event.setSpecifications(Lists.newArrayList());
    return event;
}

Pros: Leverages Guava’s battle-tested utilities, adds runtime type safety.
Cons: Requires a Guava dependency if you don’t already use it.

2. Manual Element Casting with Explicit Type Checks #

Skip external libraries entirely by iterating through each element, validating its type, and casting it to the target class. This gives you full control over error handling:

import java.util.ArrayList;
import java.util.List;

public Event convertModelToEvent(List<Object> reportingObject, String feedName) throws ClassNotFoundException {
    Event event = new Event();
    event.setHeaderReference(new HeaderReference());
    
    Class<?> targetClass = Class.forName(feedName);
    List<Object> typedList = new ArrayList<>(reportingObject.size());
    
    for (Object obj : reportingObject) {
        if (targetClass.isInstance(obj)) {
            typedList.add(targetClass.cast(obj));
        } else {
            // Customize this: throw an exception, log a warning, or skip invalid elements
            throw new IllegalArgumentException(
                String.format("Element %s is not an instance of %s", obj, targetClass.getName())
            );
        }
    }
    
    // Safe cast since we've verified all elements
    @SuppressWarnings("unchecked")
    List<Object> safeTypedList = (List<Object>) typedList;
    
    event.setPayload(new Payload(safeTypedList));
    event.setSpecifications(Lists.newArrayList());
    return event;
}

Pros: No external dependencies, full control over type validation.
Cons: Requires manual iteration, but this is a small trade-off for safety.

3. Stream API for Concise Casting #

Use Java 8+ Stream API to simplify the iteration and casting process, making your code cleaner and more readable:

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

public Event convertModelToEvent(List<Object> reportingObject, String feedName) throws ClassNotFoundException {
    Event event = new Event();
    event.setHeaderReference(new HeaderReference());
    
    Class<?> targetClass = Class.forName(feedName);
    List<?> typedList = reportingObject.stream()
            .map(targetClass::cast) // Throws ClassCastException on invalid elements
            .collect(Collectors.toList());
    
    event.setPayload(new Payload(typedList));
    event.setSpecifications(Lists.newArrayList());
    return event;
}

Pros: Clean, modern syntax; integrates seamlessly with Java 8+.
Cons: Throws an exception immediately on the first invalid element. If you want to skip bad elements instead, add a filter:

List<?> typedList = reportingObject.stream()
        .filter(targetClass::isInstance)
        .map(targetClass::cast)
        .collect(Collectors.toList());

4. Collections.checkedList for Runtime Type Enforcement #

Java’s built-in Collections.checkedList creates a wrapper that enforces type checks for all future operations on the list (like adding/removing elements):

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public Event convertModelToEvent(List<Object> reportingObject, String feedName) throws ClassNotFoundException {
    Event event = new Event();
    event.setHeaderReference(new HeaderReference());
    
    Class<?> targetClass = Class.forName(feedName);
    // Create a checked list that validates all modifications
    List<?> typedList = Collections.checkedList(new ArrayList<>(reportingObject), targetClass);
    
    event.setPayload(new Payload(typedList));
    event.setSpecifications(Lists.newArrayList());
    return event;
}

Pros: Automatically enforces type safety for any changes to the list after conversion.
Cons: Doesn’t validate existing elements in the original list—you’ll need to iterate manually if you want to check those first.

Keep in mind that Java’s type erasure means you can’t get a fully compile-time type-safe List<T> here, but these approaches minimize risk and add runtime safety based on your needs.

内容的提问来源于stack exchange，提问作者kaviya .P