记录一个工具类，作用的将List集合里的map对象里面的value的值，去重！

package .warning.util;

import java.util.*;

/**
 * TODO:根据map里面两个字段去重
 * @author 
 * @version 1.0
 * @description TODO
 * @date 2019/10/18 18:08
 **/
public class ListMapUtil {

    public static List<Map<String, String>> toDistinctList(List<Map<String, String>> list) {

        //新建set集合，利用set集合元素不能重复特点，找出重复数据
        Set<DispatchCommandsPo> keysSet = new HashSet<DispatchCommandsPo>();

        //定义两个变量
        String equipmentNo = "";
        String depotName = "";

        Iterator<Map<String, String>> it=list.iterator();
        while(it.hasNext()) {
            Map<String, String> map=it.next();
            //变量用来保存两个key所对应的值
            equipmentNo = (String) map.get("equipmentNo");
            depotName = (String) map.get("depotName");

            //新建一个对象，并重写equals和hashcode方法
            DispatchCommandsPo  dispatchCommandsPo = new DispatchCommandsPo();
            dispatchCommandsPo.setEquipmentNo(equipmentNo);
            dispatchCommandsPo.setDepotName(depotName);

            int beforeSize = keysSet.size();
            keysSet.add(dispatchCommandsPo);
            int afterSize = keysSet.size();
            //判断当前对象是否保存进set集合中（若未保存说明set集合已存在该数据，删除该条map数据）
            if(afterSize != (beforeSize + 1)) {
                it.remove();
            }
        }
        return list;
    }
    static class DispatchCommandsPo {

        private String equipmentNo;
        private String depotName;

        public String getEquipmentNo() {
            return equipmentNo;
        }

        public void setEquipmentNo(String equipmentNo) {
            this.equipmentNo = equipmentNo;
        }

        public String getDepotName() {
            return depotName;
        }

        public void setDepotName(String depotName) {
            this.depotName = depotName;
        }

        //重写hashcode方法
        @Override
        public int hashCode() {
            int result = 17;
            result = 31 * result + (equipmentNo == null ? 0 : equipmentNo.hashCode());
            result = 31 * result + (depotName == null ? 0 : depotName.hashCode());
            return result;
        }

        //重写equals方法
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof DispatchCommandsPo) {
                DispatchCommandsPo dispatchCommandsPo = (DispatchCommandsPo) obj;
                if (equipmentNo.equalsIgnoreCase(dispatchCommandsPo.getEquipmentNo().trim()) &&
                        depotName.equalsIgnoreCase(dispatchCommandsPo.getDepotName().trim())) {
                    return true;
                }
            }
            return false;
        }

    }


    public static List<Map<String, String>> toDistinctList2(List<Map<String, String>> list) {

        //新建set集合，利用set集合元素不能重复特点，找出重复数据
        Set<DispatchCommandsPo2> keysSet = new HashSet<DispatchCommandsPo2>();

        //定义两个变量
        String fenceName = "";

        Iterator<Map<String, String>> it=list.iterator();
        while(it.hasNext()) {
            Map<String, String> map=it.next();
            //变量用来保存两个key所对应的值
            fenceName = (String) map.get("fenceName");

            //新建一个对象，并重写equals和hashcode方法
            DispatchCommandsPo2  dispatchCommandsPo2 = new DispatchCommandsPo2();
            dispatchCommandsPo2.setFenceName(fenceName);


            int beforeSize = keysSet.size();
            keysSet.add(dispatchCommandsPo2);
            int afterSize = keysSet.size();
            //判断当前对象是否保存进set集合中（若未保存说明set集合已存在该数据，删除该条map数据）
            if(afterSize != (beforeSize + 1)) {
                it.remove();
            }
        }
        return list;
    }

    static class DispatchCommandsPo2 {

        private String fenceName;

        public String getFenceName() {
            return fenceName;
        }

        public void setFenceName(String fenceName) {
            this.fenceName = fenceName;
        }

        //重写hashcode方法
        @Override
        public int hashCode() {
            int result = 17;
            result = 31 * result + (fenceName == null ? 0 : fenceName.hashCode());
            return result;
        }

        //重写equals方法
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof DispatchCommandsPo2) {
                DispatchCommandsPo2 dispatchCommandsPo2 = (DispatchCommandsPo2) obj;
                if (fenceName.equalsIgnoreCase(dispatchCommandsPo2.getFenceName().trim())) {
                    return true;
                }
            }
            return false;
        }

    }
}