Java方法-对指定信息基于相关维度进行分组

近期项目中需要针对多种不同来源指定的相同类型内容进行合并，实现过程中需要根据指定的相关维度，对资源内容进行分组，如识别是否可以为同一人员信息，是否为同一个歌曲或影视信息，因此针对实现的具体细节做如下备份，以供后期查看和使用，如果有错误问题，敬请指正！

public void Map<String,Set<String>> groupByPersonByVideoName(){
        // 获取对应人员下的的影视信息，判别该人员是否可以合并为一个人，假设当前已进行获取人员的影视信息(key为personId，value为不同来源的视频名称)
        Map<String,Set<String>> authorVideoNames = Maps.newHashMap();
        
        List<String> sourceKeys = CollectionUtil.set2List(authorVideoNames.keySet());
        
        // 最终分组
        List<Set<String>> groups = Lists.newArrayList();
        // 采用冒泡排序的方法，进行两两比较，如果有相同的视频名称，则判定为同一个人
        for(int i = 0; i < sourceKeys.size(); i++){
            Set<String> group = Sets.newHashSet();
            for(int j = i; j < sourceKeys.size(); j++){
                if(i == j || CollectionUtil.hasSameItems(authorVideoNames.get(sourceKeys.get(i)),authorVideoNames.get(sourceKeys.get(j)))){
                    group.add(sourceKeys.get(j));
                }
            }
            groups.add(group);
        }

        // 判断分组之间是否存在包含的关系，即三个来源A、B、C，A和B中有对应的相同影视，B和C中有另一相同的影视信息，则判定A、B、C为同一人员
        List<Set<String>> finalGroups = Lists.newArrayList();
        for(int i = 0; i < groups.size(); i++){
            Set<String> finalGroup = Sets.newHashSet();
            for(int j = i; j < groups.size(); j++){
                // 如果已经分组过，则不需要再处理
                if(CollectionUtil.isContainsElesInColl(finalGroups,groups.get(j))){
                    continue;
                }
                // 如果有相同的名称信息，则加入以处理过分组中
                if(i == j || CollectionUtil.hasSameItems(groups.get(i),groups.get(j))){
                    finalGroup.addAll(groups.get(j));
                }
            }
            if(finalGroup.size() > 0){
                finalGroups.add(finalGroup);
            }
        }
        return finalGroups;
    }

相关的工具类，封装如下：

import java.util.*;

public class CollectionUtil {

    /**
     * 将list转换为set
     * @param list
     * @param <T>
     * @return
     */
    public static <T> Set<T> list2Set(List<T> list){
        Set<T> set = new LinkedHashSet<T>();
        for(T ele : list){
            set.add(ele);
        }
        return set;
    }

    /**
     * 将set转为list
     * @param set
     * @param <T>
     * @return
     */
    public static <T> List<T> set2List(Set<T> set){
        List<T> list = new ArrayList<T>();
        for(T ele : set){
            list.add(ele);
        }
        return list;
    }

    /**
     * 判断数组中是否具有相同的信息
     * @param list1
     * @param list2
     * @return
     */
    public static <T> boolean hasSameItems(Collection<T> list1, Collection<T> list2){
        for(T info : list1){
            if(list2.contains(info)){
                return true;
            }
        }
        return false;
    }

    /**
     * 判断分组中是否包含所有的元素
     * @param groups
     * @param infos
     * @return
     */
    public static boolean isContainsElesInColl(List<Set<String>> groups, Set<String> infos){
        if(groups.size() == 0 || infos.size() == 0){
            return false;
        }
        for(String info : infos){
            for(Set<String> group : groups){
                if(group.contains(info)){
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 判断分组中是否包含指定元素
     * @param groups
     * @param sourceKey
     * @return
     */
    public static boolean isContainsEleInColl(List<Set<String>> groups, String sourceKey){
        for(Set<String> group : groups){
            if(group.contains(sourceKey)){
                return true;
            }
        }
        return false;
    }

}