map、set、list之间转换

一、map & list

1.map2List

private static List<String> map2List(List<String> list,Map<String, String> map){
    Iterator itObtain = map.keySet().iterator();
    while (itObtain.hasNext()){
        String key = String.valueOf(itObtain.next());
        if(StringUtils.isNotBlank(key) && !key.equals("null")){
            list.add(key);
        }
    }
    return list;
}

2.list2map

private Map<Integer,String> list2map(List<AreaVO> provinces){
    Map<Integer,String> map = new HashMap<>();
    for (AreaVO area:provinces) {
        map.put(area.getId(),area.getName());
    }
    return map;
}

二、set & list

1.set2List-1

private static List<String> set2List(List<String> list,Set<String> finished){
    List<String> ls=new ArrayList(finished);
    for (String str:ls) {
        list.add(str);
    }
    return list;
}

2.set2List-2

Set<String> idsSet = new HashSet<>();
List<String> ids = new ArrayList(idsSet);

三、map & set

1.map2Set-1

private static Set<String> map2Set(Set<String> set,Map<String, String> map){
    Iterator itObtain = map.keySet().iterator();
    while (itObtain.hasNext()){
        String key = String.valueOf(itObtain.next());
        if(StringUtils.isNotBlank(key) && !key.equals("null")){
            set.add(key);
        }
    }
    return set;
}

2.map2Set-1-2

	Set<String> graphSetC = map.keySet();
	for (String str:graphSetC) {
	
	}

四、set & set

1.2个set的并集

    private static Set<String> addSetKey(Set<String> set,Set<String> set2){
        for (String str:set2) {
            set.add(str);
        }
        return set;
    }

五、list & list

1.两个List集合是否相等

/**
* 比较两个List集合是否相等
* <p>注：1. 如果一个List的引用为<code>null</code>，或者其包含的元素个数为0，那么该List在本逻辑处理中都算作空；
* <p>2. 泛型参数E涉及到对象，所以需要确保正确实现了对应对象的<code>equal()</code>方法。
* @param list1
* @param list2
* @return
*/
public static <E>boolean isListEqual(List<E> list1, List<E> list2) {
    // 两个list引用相同（包括两者都为空指针的情况）
    if (list1 == list2) {
        return true;
    }
    // 有1个为空即为真 [仅适用于此处逻辑]
    if ((list1 == null || list1.size() == 0) || (list2 == null || list2.size() == 0)) {
        return true;
    }

    // 两个list都为空（包括空指针、元素个数为0）
//        if ((list1 == null && list2 != null && list2.size() == 0)
//                || (list2 == null && list1 != null && list1.size() == 0)) {
//            return true;
//        }

    // 两个list元素个数不相同
    if (list1.size() != list2.size()) {
        return false;
    }

    // 两个list元素个数已经相同，再比较两者内容
    // 采用这种可以忽略list中的元素的顺序
    // 涉及到对象的比较是否相同时，确保实现了equals()方法
    if (!list1.containsAll(list2)) {
        return false;
    }

    return true;
}

2.compare2List 2个List的交集-1

private static List<model> compare2List(List<model> tabelList,List<String> CacheList){
    List<model> tempList = new ArrayList<>();
    for (model temp:tabelList) {
        Long id = temp.getId();
        if(id == null){
            continue;
        }
        for (String str:CacheList) {
            if(StringUtils.isBlank(str)){
                continue;
            }
            if(str.equals(id.toString())){
                tempList.add(temp);
                continue;
            }
        }
    }
    return tempList;
}

3.取2个List的交集-2

    /**
     * 获取已在池中存在的券,并过滤放在errorList里返回
     * @param ticketKeys
     * @return
     */
    private static List<String> removeExisting(List<String> ticketKeys,List<String> errorList){
        List<String> temp = new ArrayList<>();
//        List<String> existing = dao.getExisting(ticketKeys);
        List<String> existing = getFalseDate();
        
//        这2种都可以
//        Iterator it = existing.iterator();
//        while (it.hasNext()){
//            String existingTicketKeys = String.valueOf(it.next());
//            if("null".equals(existingTicketKeys)|| StringUtils.isBlank(existingTicketKeys)){
//                continue;
//            }
//            if(ticketKeys.contains(existingTicketKeys)){
//                ticketKeys.remove(existingTicketKeys);
//                errorList.add(existingTicketKeys);
//
//            }
//        }
//
//        return ticketKeys;

        for (String putKeyParam:ticketKeys) {
            if("null".equals(putKeyParam)|| StringUtils.isBlank(putKeyParam)){
                continue;
            }
            if(existing.contains(putKeyParam)){  //已存在
                errorList.add(putKeyParam);
            }else{
                temp.add(putKeyParam);
            }
        }

        return temp;
    }

    public static  List<String> getFalseDate(){
        List<String> existing = new ArrayList<>();
        existing.add("AAROH_xIpeffAs_-naABEFoeiGZ6RJD-f5S-W8trmqiDtkdwLCU");
        existing.add("AAROH_xIpeffAs_-naABEFoeD6FyxnqlOMpTELocYcdg5-wsY5o");
        return existing;

    }
    public static void main(String args[]){
        List<String> ticketKeys = new ArrayList<>();
        List<String> errorList = new ArrayList<>();
        ticketKeys.add("22222");
        ticketKeys.add("aa2");
        ticketKeys.add("aa1");
        ticketKeys.add("333333");
        System.out.println("===start ticketKeys==="+ticketKeys.toString());
        ticketKeys = removeExisting(ticketKeys,errorList);
        System.out.println("===end ticketKeys==="+ticketKeys.toString());
        System.out.println("返回值end errorList==="+errorList.toString());

    }

4.list 合并

private List<String> mergeList(List<String> list1,List<String> list2){
    if(CollectionUtils.isNotEmpty(list2)){
        for (String str:list2) {
            list1.add(str);
        }
    }
    return list1;
}

六 google MapDifference工具

Java Map 求交集 并集 差集

import com.google.common.collect.MapDifference;
import com.google.common.collect.Maps;

import java.util.Map;

public class MapUtil {

    /**
     * difference
     * Maps.difference(Map, Map)用来比较两个Map以获取所有不同点。该方法返回MapDifference对象
     */
    public static void u(Map<String,Object> map1, Map<String,Object> map2) {
        MapDifference<String, Object> difference = Maps.difference(map1, map2);
        // 是否有差异，返回boolean
        boolean areEqual = difference.areEqual();
        System.out.println("比较两个Map是否有差异:" + areEqual);
        // 两个map的交集
        Map<String, Object> entriesInCommon = difference.entriesInCommon();
        System.out.println("两个map都有的部分（交集）===：" + entriesInCommon);
        // 键相同但是值不同值映射项。返回的Map的值类型为MapDifference.ValueDifference，以表示左右两个不同的值
        Map<String, MapDifference.ValueDifference<Object>> entriesDiffering = difference.entriesDiffering();
        System.out.println("键相同但是值不同值映射项===：" + entriesDiffering);
        // 键只存在于左边Map的映射项
        Map<String, Object> onlyOnLeft = difference.entriesOnlyOnLeft();
        System.out.println("键只存在于左边Map的映射项:" + onlyOnLeft);
        // 键只存在于右边Map的映射项
        Map<String, Object> entriesOnlyOnRight = difference.entriesOnlyOnRight();
        System.out.println("键只存在于右边Map的映射项:" + entriesOnlyOnRight);
    }
}

    /**
     * 参考：
     * 作者：liuliangzhuo
     * 链接：https://juejin.cn/post/6913746999024353288
     * 来源：掘金
     */