创建setter以提供java列表实现类

我正在基于此接口编写一个小型类型转换框架：

import java.util.List;

public interface ListFactory<T> {
    List<T> newList();
}

公共接口转换器{
公共转换（最终从）；
}

这样我就可以编写自定义类型转换器，例如

公共类BigDecimal2Double实现转换器{
@凌驾
公共双精度转换（最终的BigDecimal值）{
返回值！=null？值。doubleValue（）：null；
}
}

下面的类旨在扩展转换器处理数据列表的能力

公共抽象类ListConverter实现转换器{
公共列表转换列表（列表fromList）{
if（fromList==null）{returnnull；}
List toList=new ArrayList（）；//默认实现
for（From:fromList）{
toList.add（this.convert（from））；
}
返回收费表；
}
公共静态列表转换器扩展（最终转换器）{
返回新的ListConverter（）{
@凌驾
要转换的公共文件（从）{
返回转换器。转换（从）；
}
};
}
}

因此，我可以编写客户机代码，例如：

ListConverter lcb2d=ListConverter.extend（新的BigDecimal2Double（））；
List bdList=retrieveSomeBigDecList（）；
List convertedList=lcb2d.convertList（bdList）；

如您所见，这只能为转换后的列表提供默认的

ArrayList

实现

我想添加提供不同于客户端代码的

列表

实现的功能，例如：

ListConverter lcb2d=ListConverter.extend（新的BigDecimal2Double（））；
List bdList=retrieveSomeBigDecList（）；
lcbd.setToListImplementation（LinkedList.class）；//如何定义这种方法？
List convertedList=lcb2d.convertList（bdList）；//将是一个链接列表

我怎样才能做到呢？ 类中的以下代码未编译：

---

private Class同时，问题被标记为。但如果不是，您可以添加一个版本，如

public abstract class ListConverter<From,To> implements Converter<From,To> {

    public List<To> convertList(List<From> fromList){
        … // as before
    }

    public List<To> convertList(List<From> fromList, Supplier<List<To>> supplier){
        if (fromList == null) {return null;}
        List<To> toList = supplier.get();

        for(From from: fromList ){
            toList.add(this.convert(from));
        }

        return toList;
    }

    public static <From,To> ListConverter<From, To> extend(final Converter<From, To> converter){
        return (From from) -> converter.convert(from);
    }
}

以获取LinkedList而不是ArrayList

顺便说一句，如果你习惯了Streams API，你就不需要这个ListConverter了。你可以把清单拿出来做

list.stream().map(converter::convert).collect(Collectors.toList())

或者，根据需要

list.stream().map(converter::convert).collect(Collectors.toCollection(LinkedList::new))

同时，这个问题被标记为。但如果不是，您可以添加一个版本，如

public abstract class ListConverter<From,To> implements Converter<From,To> {

    public List<To> convertList(List<From> fromList){
        … // as before
    }

    public List<To> convertList(List<From> fromList, Supplier<List<To>> supplier){
        if (fromList == null) {return null;}
        List<To> toList = supplier.get();

        for(From from: fromList ){
            toList.add(this.convert(from));
        }

        return toList;
    }

    public static <From,To> ListConverter<From, To> extend(final Converter<From, To> converter){
        return (From from) -> converter.convert(from);
    }
}

以获取LinkedList而不是ArrayList

顺便说一句，如果你习惯了Streams API，你就不需要这个ListConverter了。你可以把清单拿出来做

list.stream().map(converter::convert).collect(Collectors.toList())

或者，根据需要

list.stream().map(converter::convert).collect(Collectors.toCollection(LinkedList::new))

为类
ListConverter
的用户提供一种方法，以提供工厂方法来创建所需的特定类型的
List
。例如：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public abstract class ListConverter<From, To> implements Converter<From, To> {

    private final Supplier<List<To>> listFactory;

    public ListConverter(Supplier<List<To>> listFactory) {
        this.listFactory = listFactory;
    }

    public List<To> convertList(List<From> fromList) {
        if (fromList == null) {
            return null;
        }

        List<To> toList = listFactory.get();
        for (From from : fromList) {
            toList.add(this.convert(from));
        }

        return toList;
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter, Supplier<List<To>> listFactory) {
        return new ListConverter<From, To>(listFactory) {

            @Override
            public To convert(From from) {
                return converter.convert(from);
            }
        };
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter) {
        return extend(converter, ArrayList::new);
    }
}

编辑-对于Java 5-7，您可以创建一个
列表工厂
界面：

import java.util.List;

public interface ListFactory<T> {
    List<T> newList();
}

import java.util.List；
公共接口列表工厂{
List newList（）；
}

然后使用它，并使用匿名内部类而不是Java 8方法引用：

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

public abstract class ListConverter<From, To> implements Converter<From, To> {

    private final ListFactory<To> listFactory;

    public ListConverter(ListFactory<To> listFactory) {
        this.listFactory = listFactory;
    }

    public List<To> convertList(List<From> fromList) {
        if (fromList == null) {
            return null;
        }

        List<To> toList = listFactory.newList();
        for (From from : fromList) {
            toList.add(this.convert(from));
        }

        return toList;
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter, ListFactory<To> listFactory) {
        return new ListConverter<From, To>(listFactory) {
            @Override
            public To convert(From from) {
                return converter.convert(from);
            }
        };
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter) {
        return extend(converter, new ListFactory<To>() {
            @Override
            public List<To> newList() {
                return new ArrayList<To>();
            }
        });
    }
}

import java.util.ArrayList；
导入java.util.List；
公共抽象类ListConverter实现转换器{
私营上市公司；
公共ListConverter（ListFactory ListFactory）{
this.listFactory=listFactory；
}
公共列表转换列表（列表fromList）{
if（fromList==null）{
返回null；
}
List toList=listFactory.newList（）；
for（From:fromList）{
toList.add（this.convert（from））；
}
返回收费表；
}
公共静态ListConverter扩展（转换器转换器、ListFactory ListFactory）{
返回新的ListConverter（listFactory）{
@凌驾
要转换的公共文件（从）{
返回转换器。转换（从）；
}
};
}
公共静态列表转换器扩展（转换器）{
返回扩展（转换器，新ListFactory（）{
@凌驾
公共列表newList（）{
返回新的ArrayList（）；
}
});
}
}
为类
ListConverter
的用户提供一种方法，以提供工厂方法来创建所需的特定类型的
列表。例如：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public abstract class ListConverter<From, To> implements Converter<From, To> {

    private final Supplier<List<To>> listFactory;

    public ListConverter(Supplier<List<To>> listFactory) {
        this.listFactory = listFactory;
    }

    public List<To> convertList(List<From> fromList) {
        if (fromList == null) {
            return null;
        }

        List<To> toList = listFactory.get();
        for (From from : fromList) {
            toList.add(this.convert(from));
        }

        return toList;
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter, Supplier<List<To>> listFactory) {
        return new ListConverter<From, To>(listFactory) {

            @Override
            public To convert(From from) {
                return converter.convert(from);
            }
        };
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter) {
        return extend(converter, ArrayList::new);
    }
}

编辑-对于Java 5-7，您可以创建一个
列表工厂
界面：

import java.util.List;

public interface ListFactory<T> {
    List<T> newList();
}

import java.util.List；
公共接口列表工厂{
List newList（）；
}

然后使用它，并使用匿名内部类而不是Java 8方法引用：

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

public abstract class ListConverter<From, To> implements Converter<From, To> {

    private final ListFactory<To> listFactory;

    public ListConverter(ListFactory<To> listFactory) {
        this.listFactory = listFactory;
    }

    public List<To> convertList(List<From> fromList) {
        if (fromList == null) {
            return null;
        }

        List<To> toList = listFactory.newList();
        for (From from : fromList) {
            toList.add(this.convert(from));
        }

        return toList;
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter, ListFactory<To> listFactory) {
        return new ListConverter<From, To>(listFactory) {
            @Override
            public To convert(From from) {
                return converter.convert(from);
            }
        };
    }

    public static <From, To> ListConverter<From, To> extend(Converter<From, To> converter) {
        return extend(converter, new ListFactory<To>() {
            @Override
            public List<To> newList() {
                return new ArrayList<To>();
            }
        });
    }
}

import java.util.ArrayList；
导入java.util.List；
公共抽象类ListConverter实现转换器{
私营上市公司；
公共ListConverter（ListFactory ListFactory）{
this.listFactory=listFactory；
}
公共列表转换列表（列表fromList）{
if（fromList==null）{
返回null；
}
List toList=listFactory.newList（）；
for（From:fromList）{
toList.add（this.convert（from））；
}
返回收费表；
}
公共静态ListConverter扩展（转换器转换器、ListFactory ListFactory）{
返回新的ListConverter（listFactory）{
@凌驾
要转换的公共文件（从）{
返回转换器。转换（从）；
}
};
}
公共静态列表转换器扩展（转换器）{
返回扩展（转换器，新ListFactory（）{
@凌驾
公共列表newList（）{
返回新的ArrayList（）；
}
});
}
}
很抱歉，我忘了告诉你我正在使用java 7，我正在寻找java 5+解决方案。感谢您的回复：）@TitoZoeChiacchiera然后您可以用自己的接口替换
供应商
，并使用匿名内部类，而不是方法引用或lambda表达式