上期讲解了Java多线程查表(封装方法 多表通用)https://blog.csdn.net/weixin_56567361/article/details/128021905

因为是通用方法 返回的结果值为泛型List<T>类型

在使用list时 需要转换为list对象

下面我将对比三种转换方法：

1 阿里巴巴fastJson方法 

2 JAVA反射方式转换

3 强转方式

直接上测试图

数据量约18w条
阿里巴巴fastJson方式转换: 726 ms
JAVA反射方式转换: 15 ms
强转方式: 16 ms

数据量多时JSON.toJSONString会很慢

java发射方式和强转方法比阿里巴巴fastJson方式快了40多倍

JAVA反射方式转换 未做类型校验 这样转换并不安全

List<T> mapList = (List<T>)jsonObject.get("list");

强转方式 最适合 首先判断obj是否是List类型，然后使用class.cast做类型转换

 JsonUtils

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.compress.utils.Lists;

import java.lang.reflect.Field;
import java.util.*;

/**
 * Json转换工具类
 *
 */
public class JsonUtils {

    public static List<Field> fields = null;

    /**
     * 泛型List转List对象
     * 比JSON.parseArray(JSON.toJSONString(),T.class)
     * 快40倍
     *
     * @param obj 转换参数
     * @param cla 实体类
     * @param <T> 泛型
     * @return
     */
    public static <T> List<T> toList(Object obj, Class<T> cla) {
        List<T> list = new ArrayList<T>();
        //判断参数是否为List类型
        if (obj instanceof List<?>) {
            for (Object o : (List<?>) obj) {
                //将父类对象强制转换为子类对象
                list.add(cla.cast(o));
            }
            return list;
        }
        return null;
    }

    /**
     * List对象转List<map>
     *
     * @param list
     * @return
     * @throws IllegalAccessException
     */
    public static List<Map<String, Object>> toMap(List<?> list) throws IllegalAccessException {
        List<Map<String, Object>> mapList = new ArrayList<>();
        for (Object o : list) {
            Map<String, Object> map = objToMap(o);
            mapList.add(map);
        }
        return mapList;
    }

    /**
     * 对象转map
     *
     * @param object
     * @return
     * @throws IllegalAccessException
     */
    public static Map<String, Object> objToMap(Object object) throws IllegalAccessException {
        Map<String, Object> map = new HashMap<>();
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            map.put(field.getName(), field.get(object));
        }
        return map;
    }

    /**
     * 反射方式拿到类的field集合
     */
    public static <T> void init(T vo) {
        Class<?> aClass = vo.getClass();
        fields = Lists.newArrayList();
        for (Class<?> i = aClass; i != Object.class; i = i.getSuperclass()) {
            Field[] declaredFields = i.getDeclaredFields();
            Collections.addAll(fields, declaredFields);
        }
    }

    /**
     * 反射方式  泛型List转为List对象
     *
     * @param vo
     * @param T
     * @param <T>
     * @return
     * @throws IllegalAccessException
     */
    public static <T> List<T> testReflection(List<?> vo, Class<T> T) throws IllegalAccessException {
        if (fields == null) {
            init(vo);
        }
        JSONObject jsonObject = new JSONObject();
        for (Field field : fields) {
            field.setAccessible(true);
            jsonObject.put(field.getName(), field.get(vo));
        }
        //未做类型校验 这样转换并不安全
        List<T> mapList = (List<T>)jsonObject.get("list");
        return mapList;
    }
}

 至此本篇文章就讲到这里啦

如果有什么写的不对的或问题 欢迎留言讨论~😋