【Java】求两集合的交集、并集、差集

ゝ一世哀愁。 2023-10-12 18:36 48阅读 0赞

## 一、内置函数实现 ##

**1、removeAll方法：从list中删除指定集合中包含的所有元素。  
2、retainAll方法：从list中删除指定集合中不包含的所有元素。  
3、addAll方法：用来向Set集合添加另一个集合对象所包含的所有内容。**

public class CollectionTest {
        
     
        public static void main(String[] args) {
        
            List<String> list1 = new ArrayList<>();
            List<String> list2 = new ArrayList<>();
     
            list1.add("a");
            list1.add("b");
            list1.add("c");
     
            list2.add("b");
            list2.add("e");
            list2.add("d");
     
            //求交集
            list1.retainAll(list2);
            System.out.println(list1.toString()); // b
     
            //求并集
            list1.removeAll(list2);
            list1.addAll(list2);
            System.out.println(list1.toString());  // a c b e d
     
            //求差集(list1有而list2没有)
            list1.removeAll(list2);   // a c
     
        }
    }

参考链接：[https://www.cnblogs.com/hxf-zb/p/16102135.html][https_www.cnblogs.com_hxf-zb_p_16102135.html]

## 二、for循环遍历实现 求两个集合的交集 ##

利用集合的contains方法，来对比第二个集合中是否存在相同的元素的方法，同时将交集结果返回。时间复杂度是O(n)。  
**contains方法：用于判断list集合是否包含某个元素。**

public List<Object> intersectionForList_1(List<Object> arr1, List<Object> arr2) {
        
        long startTime = System.currentTimeMillis();
        List<Object> result = new ArrayList<>();
        for (Object arr : arr1) {
        
            if (arr2.contains(arr)) {
        
                result.add(arr);
             }
        }
        long endTime = System.currentTimeMillis();
        log.info("intersectionForList_1：" + (endTime - startTime));
        return result;
    }

## 三、使用Java 8 Stream API 求两个集合的交集 ##

首先把两个集合转换成Stream，然后使用filter()方法筛选出交集元素，最后把结果转换成集合。 时间复杂度是O(n)。  
**.stream().filter()方法：来筛选出满足条件的对象，最终返回的筛选过后的列表。**  
**Collectors.toList()和Collectors.toSet()方法都是将map后的stream转换为一个列表对象，toSet()会去重重复的对象**

Set<Integer> set1 = new HashSet<>();
    set1.add(1);
    set1.add(2);
    set1.add(3);
    set1.add(4);
    
    Set<Integer> set2 = new HashSet<>();
    set2.add(3);
    set2.add(4);
    set2.add(5);
    Set<Integer> intersection = set1.stream().filter(set2::contains).collect(Collectors.toSet());
    System.out.println(intersection); // 输出 [3, 4]

## 四、使用迭代器求两个集合的交集 ##

public List<Object> intersectionForList_2(List<Object> arr1, List<Object> arr2) {
        
    
          List<Object> resultList = new ArrayList<>();
     
          List<Object> maxList;
          List<Object> minList;
          if (arr1.size()>arr2.size()){
        
              maxList = arr1;
              minList = arr2;
          }else {
        
              maxList = arr2;
              minList = arr1;
          }
     
          Iterator<Object> iterator = maxList.iterator();
          while (iterator.hasNext()){
        
              Object next = iterator.next();
              if (minList.contains(next)){
        
                  resultList.add(next);
              }
          }
     
    
          return resultList;
      }

## 五、使用map 求两个集合的交集 ##

首先将list集合中的元素依次存入一个map中去，然后再以map的get方法来判断是否存在这样的元素。  
这种方法的效率最高，在10万条数据的测试下，这种方法耗时仅仅在十几毫秒，而其他方法在将近一百多毫秒。  
在百万条数据进行对比处理的时候，使用map特性的方法时间消耗大概在40毫秒左右，但是其他方法要将近10秒钟，  
所以在对于大量数据的处理过程中，还是非常建议使用这种方法的。

public List<Object> intersectionForList_3(List<Object> arr1, List<Object> arr2) {
        
    
        List<Object> resultList = new ArrayList<>();
        Map<String,Object> map = new HashMap<>();
        arr1.forEach(a1->{
        
             map.put(a1+"",a1);
        });
     
        arr2.forEach(a2->{
        
            Object obj = map.get(a2 + "");
            if (obj!=null){
        
                resultList.add(obj);
            }
        });
    
        return resultList;
    }

参考链接：[https://blog.csdn.net/jcc4261/article/details/127357403][https_blog.csdn.net_jcc4261_article_details_127357403]

[https_www.cnblogs.com_hxf-zb_p_16102135.html]: https://www.cnblogs.com/hxf-zb/p/16102135.html
[https_blog.csdn.net_jcc4261_article_details_127357403]: https://blog.csdn.net/jcc4261/article/details/127357403