标准化java中列表值的转换

我有一个JCR节点的

列表

，我需要将其转换为不同的模型。目前，每个模型都有一个单独的功能：

public List<MetaModel> castNodesToMetaModel(List<Node> nodes) {
    List<MetaModel> models = new ArrayList<MetaModel>();
    for (Node node : nodes) {
        models.add(new MetaModel(node, this));
    }
    return models;
}
protected List<ArticleModel> castNodesToArticleModel(List<Node> nodes) {
    List<ArticleModel> models = new ArrayList<ArticleModel>();
    for (Node node : nodes) {
        models.add(new ArticleModel(node, this));
    }
    return models;
}

---

是的，你可以，但是签名需要稍微不同

import java.lang.reflect.Constructor;

protected <T> List<T> castNodes(Class<T> clazz, List<Node>) {
    List<T> list = new ArrayList<T>();
    try {
        Constructor c = clazz.getConstructor(Node.class, getClass());        
        for (Node node : nodes)
            list.add((T) c.newInstance(node, this));
    } catch (Exception e) {
        // handle
    }
    return list;
}

import java.lang.reflect.Constructor；
受保护的列表节点（类clazz，列表）{
列表=新的ArrayList（）；
试一试{
构造函数c=clazz.getConstructor（Node.class，getClass（））；
用于（节点：节点）
add（（T）c.newInstance（node，this））；
}捕获（例外e）{
//处理
}
退货清单；
}

您不应该真正捕获一般的

异常（您应该捕获更具体的类型），但这给了您一个想法
 您可以调用通过参数
className
传递给方法的
Class
对象的方法使用Java 8方法：

public static <T> List<T> mapNodes(List<Node> nodes, Function<Node, T> mapFunction) {
        return nodes.stream().map(mapFunction).collect(Collectors.toList());
    }

公共静态列表映射节点（列表节点、函数映射函数）{
返回nodes.stream（）.map（mapFunction.collect（Collectors.toList（））；
}

他们这样称呼它：

List<MetaModel> metaModels = mapNodes(nodeList, node -> new MetaModel(node, this));

List<ArticleModel> articleModels = mapNodes(nodeList, node -> new ArticleModel(node, this));

List<MetaModel> metaModels = convertNodes(nodeList, NodeConverterFactory.metaModel(this));

List<ArticleModel> articleModels = convertNodes(nodeList, NodeConverterFactory.articleModel(this));

List metaModels=mapNodes（nodeList，node->new MetaModel（node，this））；
List articleModels=mapNodes（nodeList，node->new ArticleModel（node，this））；

****编辑****

如果您一直使用Java7，我建议您使用一种好的面向对象方法，而不是反射。例如：

public static <T> List<T> convertNodes(List<Node> nodes, NodeConverter<T> converter) {
    ArrayList<T> newNodes = new ArrayList<>();
    for (Node node : nodes) {
        newNodes.add(converter.convert(node));
    }
    return newNodes;
}

private static interface NodeConverter<T> {

    public T convert(Node node);
}
public static class NodeConverterFactory {

    public static final NodeConverter<MetaModel> metaModel(final Object thiz) {
        return new NodeConverter<MetaModel>() {
            @Override
            public MetaModel convert(Node node) {
                return new MetaModel(node, thiz);
            }
        };
    }
    public static final NodeConverter<ArticleModel> articleModel(final Object thiz) {
        return new NodeConverter<ArticleModel>() {
            @Override
            public ArticleModel convert(Node node) {
                return new ArticleModel(node, thiz);
            }
        };
    }
}

公共静态列表转换器节点（列表节点、节点转换器）{
ArrayList newNodes=新的ArrayList（）；
用于（节点：节点）{
添加（converter.convert（node））；
}
返回新节点；
}
专用静态接口节点转换器{
公共T转换（节点）；
}
公共静态类NodeConverterFactory{
公共静态最终节点转换器元模型（最终对象thiz）{
返回新的NodeConverter（）{
@凌驾
公共元模型转换（节点）{
返回新的元模型（节点，thiz）；
}
};
}
公共静态最终节点转换器articleModel（最终对象thiz）{
返回新的NodeConverter（）{
@凌驾
公共ArticleModel转换（节点）{
返回新的ArticleModel（节点，thiz）；
}
};
}
}

然后你可以这样使用：

List<MetaModel> metaModels = mapNodes(nodeList, node -> new MetaModel(node, this));

List<ArticleModel> articleModels = mapNodes(nodeList, node -> new ArticleModel(node, this));

List<MetaModel> metaModels = convertNodes(nodeList, NodeConverterFactory.metaModel(this));

List<ArticleModel> articleModels = convertNodes(nodeList, NodeConverterFactory.articleModel(this));

List metaModels=convertNodes（nodeList，NodeConverterFactory.metaModel（this））；
List articleModels=convertNodes（nodeList，NodeConverterFactory.articleModel（this））；

虽然比反射方法更详细，但它更清晰、更灵活（因为您可以实现所有类型的转换器，而不必拘泥于一种构造函数）和类型安全。如果使用的构造函数/方法不存在，反射方法可能会导致运行时问题。
构造函数是java.lang.reflect.constructor的实例吗？是。对不起，我应该添加相关的导入。@bashaus是的，您可能在可访问性方面有问题
c.setAccessible（true）
可能是必需的。@bashaus也可能您不应该传递
getClass（）
，而是传递一些
specific class.class
。一旦你开始使用反射，你就绕过了很多常规的检查，所以很难把这类事情做好。我喜欢这种方法，但我认为我们还是要使用Java7。