泛型实现通用对象工具类

    今天，项目中为了实现一个用到，需要把许多不同对象类型的list集合转化为map集合，例如：List<SchoolRoom>，List<Student>等，之前没有觉得特别麻烦，只需要为每个list集合写一个转化方法就可以了。今天实在太多，就打算自己手动写一个通用的方法。希望给小伙伴也能省下麻烦的重复工作。

演示类：

SchoolRoom类

/**
 * 考场
 */
public class SchoolRoom {

    private int id;
    private long schoolId;
    private String place;
    private int SeatNum;
    private long paperId;
    public SchoolRoom() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public long getSchoolId() {
        return schoolId;
    }

    public void setSchoolId(long schoolId) {
        this.schoolId = schoolId;
    }

    public String getPlace() {
        return place;
    }

    public void setPlace(String place) {
        this.place = place;
    }

    public int getSeatNum() {
        return SeatNum;
    }

    public void setSeatNum(int seatNum) {
        SeatNum = seatNum;
    }

    public long getPaperId() {
        return paperId;
    }

    public void setPaperId(long paperId) {
        this.paperId = paperId;
    }
}

工具类：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author dengjingsi
 * 格式化工具类
 * S为需要作为主键的类型map的key类型（T中的一个属性类型），T为map的value值
 */
public class FormatUtil<S,T> {
    /**
     * 把list格式的SchoolRoom转化为Map格式
     * @param schoolRoomList schoolRoom的数组
     * @return 返回schoolRoom的map集合格式
     */
    public static Map<Integer,SchoolRoom> formatSchoolRoomList(List<SchoolRoom> schoolRoomList){
        if(null == schoolRoomList || schoolRoomList.size() == 0){
            return new HashMap<>(0);
        }
        Map<Integer,SchoolRoom> schoolRoomMap = new HashMap<>(schoolRoomList.size());
        for(SchoolRoom schoolRoom : schoolRoomList){
            schoolRoomMap.put(schoolRoom.getId(),schoolRoom);
        }
        return schoolRoomMap;
    }

    /**
     * 把list格式的对象以property方法名获取到的属性为主键，转化为map格式
     * @param list
     * @param property
     * @return
     */
    public Map<S,T> formatList(List<T> list, String property){
        if(null == list || list.size() == 0){
            return new HashMap<>(0);
        }
        Map<S,T> map = new HashMap<>(list.size());
        try{
            for(T element : list){
                Method method = element.getClass().getMethod(property,new Class[]{});
                map.put((S)method.invoke(element,new Object[]{}),element);
            }
        }catch(NoSuchMethodException n){
            n.printStackTrace();
        }catch(InvocationTargetException it){
            it.printStackTrace();
        }catch(IllegalAccessException i){
            i.printStackTrace();
        }
        return map;
    }

    /**
     * 把list格式的对象以Id属性为主键，转化为map格式
     * @param list
     * @return
     */
    public Map<S,T> formatList(List<T> list){
        return formatList(list, "getId");
    }

    /**
     * 验证主方法
     * @param args
     */
    public static void main(String[] args){
        //初始化验证基类begin
        List<SchoolRoom> schoolRooms = new ArrayList<>();
        SchoolRoom schoolRoom;
        for(int i = 0; i<10; i++) {
            schoolRoom = new SchoolRoom();
            schoolRoom.setId(i);
            schoolRoom.setPlace(""+i);
            schoolRooms.add(schoolRoom);
        }
       //初始化验证基类end
       //通用方法
        FormatUtil<Integer,SchoolRoom> formatUtil = new FormatUtil<>();
        Map<Integer,SchoolRoom> map1 = formatUtil.formatList(schoolRooms);
        for(Map.Entry<Integer,SchoolRoom> entry: map1.entrySet()){
            System.out.println("id:"+entry.getValue().getId()+",place:"+entry.getValue().getPlace());
        }
       //普通方法
        System.out.println("-----------------------------");
        Map<Integer,SchoolRoom> map2 = FormatUtil.formatSchoolRoomList(schoolRooms);
        for(Map.Entry<Integer,SchoolRoom> entry: map2.entrySet()){
            System.out.println("id:"+entry.getValue().getId()+",place:"+entry.getValue().getPlace());
        }
    }

唯一的不同除了方便，唯一的不同就是通用的泛型解决方式需要实例化工具类，普通方法是静态方法直接用就可以了。如果有更方便的方法，希望小伙伴多多指正。