java使用流API和引用方法将一种类型的集合对象转换为另一种类型的对象

Question

我使用lambda将对象从一种类型转换为另一种类型

• 命令

@JacksonXmlRootElement(localName = "order")
public class Order {

    private String customer;

    @JacksonXmlProperty(localName = "orderItem")
    @JacksonXmlElementWrapper(useWrapping = false)
    private List<OrderItem> orderItems = new ArrayList<>();

    public Order() {
    }

• 订购

public class OrderDto {

     private String customer;

     private String orderXml;

    public OrderDto() {
    }

• 服务

@Service
public class OrderReadServiceImpl implements OrderReadService {

    private OrderEntityRepository repository;

    private OrderDtoMapper mapper;

    private CycleAvoidingMappingContext context;

    @Autowired
    public OrderReadServiceImpl(OrderEntityRepository repository,
                                OrderDtoMapper mapper,
                                CycleAvoidingMappingContext context) {
        this.repository = repository;
        this.mapper = mapper;
        this.context = context;
    }

    @Override
    public Iterable<Order> getListOrder() {

        Iterable<OrderEntity> orderEntities = this.repository.findAll();

        Iterable<Order> orders = convertXmlToListObj(orderEntities);

        return orders;
    }

    private Iterable<Order> convertXmlToListObj(Iterable<OrderEntity> entities) {

        Iterable<OrderDto> dtoList = toListDto(entities);

        Iterable<Order> orders = convertListToList(dtoList);

        return orders;
    }

    /**
     * There is convert a collection of objects one type to another type
     * @param dtoList
     * @return
     */
    private static Iterable<Order> convertListToList(Iterable<OrderDto> dtoList) {

        List<OrderDto> list = new ArrayList<>();
        dtoList.forEach(list::add);

        List<Order> collect = list.stream()
            .map(orderDto -> {
                Order order = convertXmlToObj(orderDto);
                return order;
            }).collect(Collectors.toList());

        return collect;
    }

    /**
     * there is got a string that xml. This xml is convert to java object
     * @param orderDto
     * @return
     */
    private static Order convertXmlToObj(OrderDto orderDto) {

        String orderXml = orderDto.getOrderXml();

        StringReader reader = new StringReader(orderXml);

        Order order = JAXB.unmarshal(reader, Order.class);

        return order;
    }

    /**
     * transform objects of  entity type to objects of dto types
     * @param entities
     * @return
     */
    private Iterable<OrderDto> toListDto(Iterable<OrderEntity> entities) {
        return this.mapper.toListDto(entities);
    }
}

生成的实体列表将转换为dto集合。对转换后的dto列表的集合进行迭代，并从每个集合元素的字段中检索xml，然后将该xml的结构转换为umarshall（也就是说，xml元素的列表将转换为java对象的集合）

        List<OrderDto> list = new ArrayList<>();
        dtoList.forEach(list::add);

        List<Order> collect = list.stream()
            .map(orderDto -> {
                Order order = convertXmlToObj(orderDto);
                return order;
            }).collect(Collectors.toList());

        return collect;

我想做最简单的事。我希望代码会更小

С如果你在某个地方删除了代码，如何减少它

我是说。我在哪里创建“方法引用”呢

谁知道怎么做

Answer 1

如果您想解决映射对象的一般问题，并且不想精确地寻找lambda/stream解决方案的优化，那么可以查看一下MapStruct。简化描述：它在编译时借助注释生成映射器

Answer 2

您可以直接将Iterable转换为Stream，而无需创建List：

StreamSupport.stream(dtoList.spliterator(), false)

您的代码可以成为

private static Iterable<Order> convertListToList(Iterable<OrderDto> dtoList) 
{
    return StreamSupport.stream(dtoList.spliterator(), false)
        .map(orderDto -> convertXmlToObj(orderDto))
        .collect(Collectors.toList());
}

或使用方法参考：

private static Iterable<Order> convertListToList(Iterable<OrderDto> dtoList) 
{
    return StreamSupport.stream(dtoList.spliterator(), false)
        .map(OrderReadServiceImpl::convertXmlToObj)
        .collect(Collectors.toList());
}

顺便说一句，因为您的方法名为convertListToList()，所以它可能应该接受并返回Lists而不是Iterables