[Java] Encuentra la intersección, la unión y la diferencia de dos conjuntos

1. Implementación de funciones integradas

1. Método removeAll: elimina todos los elementos contenidos en la colección especificada de la lista.
2. Método de retención: elimina todos los elementos que no están contenidos en la colección especificada de la lista.
3. Método addAll: se usa para agregar todo el contenido contenido en otro objeto de colección a la colección 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
 
    }
}

Enlace de referencia: https://www.cnblogs.com/hxf-zb/p/16102135.html

2. For loop traversal para encontrar la intersección de dos conjuntos

Utilice el método contains del conjunto para comparar si el mismo elemento existe en el segundo conjunto y devolver el resultado de la intersección al mismo tiempo. La complejidad del tiempo es O(n).
contiene el método: se utiliza para determinar si la colección de listas contiene un elemento.

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;
}

3. Use la API de flujo de Java 8 para encontrar la intersección de dos conjuntos

Primero convierta las dos colecciones en un Stream, luego use el método filter() para filtrar los elementos de intersección y finalmente convierta el resultado en una colección. La complejidad del tiempo es O(n).
Método .stream().filter(): para filtrar los objetos que cumplen las condiciones y finalmente devolver la lista filtrada.
Los métodos Collectors.toList() y Collectors.toSet() convierten la secuencia después del mapa en un objeto de lista, y toSet() eliminará los objetos duplicados.

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]

Cuarto, use iteradores para encontrar la intersección de dos conjuntos

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;
  }

5. Usa el mapa para encontrar la intersección de dos conjuntos

En primer lugar, los elementos de la colección de listas se almacenan en un mapa a su vez y, a continuación, se utiliza el método get del mapa para determinar si dichos elementos existen.
Este método tiene la mayor eficiencia.Bajo la prueba de 100.000 piezas de datos, este método toma solo una docena de milisegundos, mientras que otros métodos toman casi cien milisegundos.
Al comparar y procesar millones de datos, el uso de la función de mapa consume alrededor de 40 milisegundos, pero otros métodos tardan casi 10 segundos, por lo que se recomienda utilizar este
método en el proceso de procesamiento de una gran cantidad de datos.

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;
}

Enlace de referencia: https://blog.csdn.net/jcc4261/article/details/127357403