List<dto> 转List<map>

/**
     * list<DTO> 转 list<Map<String,Object>>
     *
     * @param list
     * @param <T>
     * @return
     */
    public static <T> List<Map<String, Object>> listConvert(List<T> list) {
        List<Map<String, Object>> list_map = new ArrayList<Map<String, Object>>(); // 定义List<Map<String, Object>>数组<br>　　　　　　　　　　// list为外部传进来的list集合
        if (CollectionUtils.isNotEmpty(list)) {
            list.forEach(item ->{// PropertyUtils.describe(Object)转换
                Map<String, Object> map = null;
                try {
                    map = (Map<String, Object>) PropertyUtils.describe(item);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
                list_map.add(map );

            });
        }
        return list_map;
    }

list<map> 转 list<dto> 使用使用alibaba json

引入依赖：

<dependency>
      <groupId>com.alibaba</groupId>
       <artifactId>fastjson</artifactId>
       <version>1.2.37</version>
    </dependency>

List<Map<String,Object>> = new ArrayList<>;

 List<InventoryNeedWeiDto>  needDtos = JSON.parseArray(JSON.toJSONString(list), InventoryNeedWeiDto.class);

list对象 转另一个list对象

<dependency>
            <groupId>ma.glasnost.orika</groupId>
            <artifactId>orika-core</artifactId>
   </dependency>

package com.liby.inventory.common.utils;

import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.impl.DefaultMapperFactory;
import ma.glasnost.orika.metadata.Type;
import java.util.List;
public abstract class BeanMapperUtils {

    private static MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

    public static <S,D> D map(S source,Class<D> clazz){
        MapperFacade mapper = mapperFactory.getMapperFacade();
        return mapper.map(source, clazz);
    }

    public static <S,D> void map(S source,D d){
        MapperFacade mapper = mapperFactory.getMapperFacade();
        mapper.map(source,d);
    }

    public static <S, D> D map(S s, Type<S> sType, Type<D> dType){
        MapperFacade mapper = mapperFactory.getMapperFacade();
        return mapper.map(s, sType, dType);
    }

    public static <S,D> List<D> mapAsList(List<S> source, Class<D> clazz){
        MapperFacade mapper = mapperFactory.getMapperFacade();
        return mapper.mapAsList(source, clazz);
    } }

BeanMapperUtils.mapAsList(S source,Class clazz);
source: 源对象 D：目标对象

对象转另一个对象

BeanMapperUtils.map(S source,Class clazz) source: 源对象 D：目标对象