package com.vote.system.util;

import java.util.*;
import java.util.stream.Collectors;

public class StreamUtils {

    /**
     * 求两个集合的并集(去除重复项)
     *
     * @param A
     * @param B
     * @return
     */
    public static List<Long> unionList(List<Long> A, List<Long> B){
        A.addAll(B);
        List<Long> AuB = A.stream().distinct().collect(Collectors.toList());
        return AuB;
    }

    /**
     * 求两个集合的交集
     *
     * @param A
     * @param B
     * @return
     */
    public static List<Long> intersectionList(List<Long> A, List<Long> B){
        List<Long> AnB = A.stream().filter(s -> B.contains(s)).collect(Collectors.toList());
        return AnB;
    }

    /**
     * 求两个集合的差集（A-B）
     *
     * @param A
     * @param B
     * @return
     */
    public static List<Long> differenceList(List<Long> A, List<Long> B){
        List<Long> difference = A.stream().filter(s -> !B.contains(s)).collect(Collectors.toList());
        return difference;
    }

    /**
     * 求两个数组的并集
     *
     * @param m
     * @param n
     * @return
     */
    public static Long[] unionArray(Long[] m, Long[] n){
        // 将数组转换为set集合
        Set<Long> setM = new HashSet<>(Arrays.asList(m));
        Set<Long> setN = new HashSet<>(Arrays.asList(n));
        // 合并两个集合
        setM.addAll(setN);

        Long[] arr = {};
        return setM.toArray(arr);
    }

    /**
     * 求两个数组的交集
     *
     * @param m
     * @param n
     * @return
     */
    public static Long[] intersectionArray(Long[] m, Long[] n){
        // 将数组转换为set集合
        List<Long> rs = new ArrayList<Long>();

        // 将较长的数组转换为set
        Set<Long> set = new HashSet<Long>(Arrays.asList(m.length > n.length ? m : n));

        // 遍历较短的数组，实现最少循环
        for (Long i : m.length > n.length ? n : m)
        {
            if (set.contains(i))
            {
                rs.add(i);
            }
        }

        Long[] arr = {};
        return rs.toArray(arr);
    }

    /**
     * 求两个数组的差集(m与交集的差集)
     *
     * @param m
     * @param n
     * @return
     */
    public static Long[] differenceArray(Long[] m, Long[] n){
        Long[] arr = {};
        Long[] min = m.length > n.length ? n : m;
        if(min == null || min.length == 0){
            return arr;
        }
// 将较长的数组转换为set
        Set<Long> set = new HashSet<Long>(Arrays.asList(m.length > n.length ? m : n));

        // 遍历较短的数组，实现最少循环
        for (Long i : min)
        {
            // 若是集合里有相同的就删掉，若是没有就将值添加到集合
            if (set.contains(i))
            {
                set.remove(i);
            } else
            {
//                set.add(i);
            }
        }

        return set.toArray(arr);
    }

    /**
     * 求两个集合的交集
     *
     * @param A
     * @param B
     * @return
     */
    public static List<String> intersectionStrList(List<String> A, List<String> B){
        List<String> AnB = A.stream().filter(s -> B.contains(s)).collect(Collectors.toList());
        return AnB;
    }

    /**
     * 求两个集合的差集
     *
     * @param A
     * @param B
     * @return
     */
    public static List<String> differenceStrList(List<String> A, List<String> B){
        List<String> difference = A.stream().filter(s -> !B.contains(s)).collect(Collectors.toList());
        return difference;
    }

}


