Как найти пересечение множеств java

Use the retainAll() method of Set:

Set<String> s1;
Set<String> s2;
s1.retainAll(s2); // s1 now contains only elements in both sets

If you want to preserve the sets, create a new set to hold the intersection:

Set<String> intersection = new HashSet<String>(s1); // use the copy constructor
intersection.retainAll(s2);

The javadoc of retainAll() says it’s exactly what you want:

Retains only the elements in this set that are contained in the specified collection (optional operation). In other words, removes from this set all of its elements that are not contained in the specified collection. If the specified collection is also a set, this operation effectively modifies this set so that its value is the intersection of the two sets.

Термин Set — это интерфейс, присутствующий в пакете java.util. Набор — это интерфейс коллекции, который хранит неупорядоченные списки и не позволяет хранить повторяющиеся сущности. Математически интерфейс набора имеет три свойства.

1. Элементы в наборе не равны нулю.
2. Никакие два элемента в наборе не могут быть равными.
3. Набор не сохраняет порядок вставки.

Используйте вставку набора и найдите пересечение набора в Java

Вы можете увидеть программу ниже, которая демонстрирует вставку набора и поиск пересечения между двумя наборами в Java.

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class SetIntersection {
    public static void main(String[] args) {
        Set<Integer> s1 = new HashSet<>();
        s1.add(2);
        s1.add(7);
        s1.add(1);
        System.out.println("Set1: " + s1);
        List list = Arrays.asList(1, 7, 6, 8);
        Set<Integer> s2 = new HashSet<>(list);
        System.out.println("Set2: " + s2);
        Set<Integer> intersection = new HashSet<>(s1);
        intersection.retainAll(s2);
        System.out.println("Intersection: " + intersection);
    }
}

В приведенном выше коде набор объявлен как первый шаг процесса. new HashSet создает новый экземпляр класса HashSet и присваивает сформированную ссылку экземпляру Set. По умолчанию емкость HashSet составляет 16, а коэффициент загрузки — 0.75. Класс HashSet совместим с интерфейсом Set, поскольку HashSet внутренне реализует интерфейс Set.

Переменная s1 инициализируется методом add. Функция добавляет объект определенного типа к экземпляру Set, учитывая, что объект не равен нулю и не дублируется. Функция возвращает логическое значение в зависимости от того, вставлено значение или нет. Функция генерирует ClassCastException, если класс указанного элемента не похож на класс экземпляра Set. Он генерирует исключение NullPointerException, если элемент имеет нулевое значение, и исключение IllegalArgumentException, если какое-либо свойство элемента запрещает его добавление в коллекцию Set.

Другой способ создать набор — использовать экземпляр list, переданный в параметр конструктора HashSet. Список инициализируется определенными значениями с помощью метода asList класса Arrays. Экземпляр списка передается как параметр в конструкторе HashSet. Коллекция Set не сохраняет порядок, в котором сохраняются элементы.

Другой экземпляр Set создается с экземпляром s1 в качестве параметра конструктора. Теперь эта ссылка пересечение вызывает другой метод — функцию keepAll. Функция сохраняет только элементы, которые присутствуют при вызове экземпляра и вызванного экземпляра. Метод возвращает boolean true, когда Set изменяется в операции keep. Он выбрасывает UnsupportedOperationException, если не поддерживает операцию над наборами. Он генерирует ClassCastException, если существуют несовместимые типы набора, и NullPointerException, если набор содержит нулевой элемент.

Результат вышеупомянутого пересечения между множествами показан ниже.

Выход:

Set1: [1, 2, 7]
Set2: [1, 6, 7, 8]
Intersection: [1, 7]

Автор оригинала: baeldung.

1. введение

Набор – это удобный способ представить уникальную коллекцию предметов.

В этом уроке мы узнаем больше о том, что это значит и как мы можем использовать его в Java.

2. Немного теории множеств

2.1. Что Такое Набор?

Набор-это просто группа уникальных вещей. Итак, существенной характеристикой любого набора является то, что он не содержит дубликатов .

Мы можем поместить в набор все, что захотим. Однако мы обычно используем наборы для группировки вещей, которые имеют общую черту. Например, у нас может быть набор транспортных средств или набор животных.

Давайте используем два набора целых чисел в качестве простого примера:

setA : {1, 2, 3, 4}

setB : {2, 4, 6, 8}

Мы можем показать наборы в виде диаграммы, просто поместив значения в круги:

Подобные диаграммы известны как диаграммы Венна и дают нам полезный способ показать взаимодействие между наборами, как мы увидим позже.

2.2. Пересечение множеств

Термин пересечение означает общие значения различных множеств .

Мы видим, что целые числа 2 и 4 существуют в обоих наборах. Таким образом, пересечение setA и setB равно 2 и 4, потому что это значения, которые являются общими для обоих наших наборов.

setA intersection setB = {2, 4}

Чтобы показать пересечение на диаграмме, мы объединяем наши два набора и выделяем область, общую для обоих наших наборов:

2.3. Объединение множеств

Термин объединение означает объединение значений различных наборов .

Итак, давайте создадим новый набор, который является объединением наших наборов примеров. Мы уже знаем, что у нас не может быть повторяющихся значений в наборе. Однако наши наборы имеют некоторые повторяющиеся значения (2 и 4). Поэтому, когда мы объединяем содержимое обоих наборов, нам нужно убедиться, что мы удалили дубликаты. Таким образом, мы получаем 1, 2, 3, 4, 6 и 8.

setA union setB = {1, 2, 3, 4, 6, 8}

Опять же, мы можем показать объединение на диаграмме. Итак, давайте объединим наши два набора и выделим область, которая представляет объединение:

2.4. Относительное дополнение множеств

Термин относительное дополнение означает значения из одного набора, которых нет в другом . Это также называется разницей в наборе.

Теперь давайте создадим новые наборы, которые являются относительными дополнениями наборов и setB .

relative complement of setA in setB = {6, 8}

relative complement of setB in setA = {1, 3}

А теперь давайте выделим область в zeta , которая не является частью set B . Это дает нам относительное дополнение set in set A :

2.5. Подмножество и Надмножество

Подмножество-это просто часть большего набора, и больший набор называется надмножеством. Когда у нас есть подмножество и надмножество, объединение этих двух равно надмножеству, а пересечение равно подмножеству.

3. Реализация Операций Набора С java.util.Set

Чтобы увидеть, как мы выполняем операции с наборами в Java, мы возьмем примеры наборов и реализуем пересечение, объединение и относительное дополнение. Итак, давайте начнем с создания наших выборочных наборов целых чисел:

private Set setA = setOf(1,2,3,4);
private Set setB = setOf(2,4,6,8);
    
private static Set setOf(Integer... values) {
    return new HashSet(Arrays.asList(values));
}

3.1. Пересечение

Во-первых, мы собираемся использовать метод retainAll для создания пересечения наших выборочных наборов . Поскольку retainAll изменяет набор напрямую, мы сделаем копию setA под названием intersectSet. Затем мы будем использовать метод retainAll , чтобы сохранить значения, которые также находятся в set B :

Set intersectSet = new HashSet<>(setA);
intersectSet.retainAll(setB);
assertEquals(setOf(2,4), intersectSet);

3.2. Союз

Теперь давайте используем метод addAll для создания объединения наших наборов образцов . Метод addAll добавляет все элементы поставляемого набора в другой. Опять же, поскольку add All обновляет набор напрямую, мы сделаем копию setA под названием union Set , а затем добавим к нему sub :

Set unionSet = new HashSet<>(setA);
unionSet.addAll(setB);
assertEquals(setOf(1,2,3,4,6,8), unionSet);

3.3. Относительное дополнение

Наконец, мы будем использовать метод removeAll для создания относительного дополнения set B в set A . Мы знаем, что нам нужны значения, которые находятся в множествах , которые не существуют в множестве B . Поэтому нам просто нужно удалить все элементы из наборов , которые также находятся в наборе B :

Set differenceSet = new HashSet<>(setA);
differenceSet.removeAll(setB);
assertEquals(setOf(1,3), differenceSet);

4. Реализация операций набора с потоками

4.1. Пересечение

Давайте создадим пересечение наших множеств с помощью Потоков .

Во-первых, мы получим значения из setA в поток. Затем мы отфильтруем поток, чтобы сохранить все значения, которые также находятся в set B . И, наконец, мы соберем результаты в новый Набор :

Set intersectSet = setA.stream()
    .filter(setB::contains)
    .collect(Collectors.toSet());
assertEquals(setOf(2,4), intersectSet);

4.2. Союз

Теперь давайте используем статический метод Streams.concat , чтобы добавить значения наших наборов в один поток .

Чтобы получить объединение из объединения наших наборов, нам нужно удалить все дубликаты. Мы сделаем это, просто собрав результаты в Набор :

Set unionSet = Stream.concat(setA.stream(), setB.stream())
    .collect(Collectors.toSet());
assertEquals(setOf(1,2,3,4,6,8), unionSet);

4.3. Относительное Дополнение

Наконец, мы создадим относительное дополнение set B в set A .

Как и в примере с пересечением, мы сначала получим значения из set в поток. На этот раз мы отфильтруем поток, чтобы удалить все значения, которые также находятся в set B . Затем мы соберем результаты в новый Набор :

Set differenceSet = setA.stream()
    .filter(val -> !setB.contains(val))
    .collect(Collectors.toSet());
assertEquals(setOf(1,3), differenceSet);

5. Служебные библиотеки для операций набора

Теперь, когда мы увидели, как выполнять базовые операции набора с помощью чистой Java, давайте использовать несколько служебных библиотек для выполнения тех же операций. Одна приятная вещь в использовании этих библиотек заключается в том, что имена методов четко сообщают нам, какая операция выполняется.

5.1. Зависимости

Чтобы использовать коллекции Guava Sets и Apache Commons SetUtils , нам нужно добавить их зависимости:

    com.google.guava
    guava
    27.1-jre


    org.apache.commons
    commons-collections4
    4.3

5.2. Наборы Гуавы

Давайте используем класс Guava Sets для выполнения пересечения и объединения на наших примерах наборов. Для этого мы можем просто использовать статические методы union и intersection класса Sets :

Set intersectSet = Sets.intersection(setA, setB);
assertEquals(setOf(2,4), intersectSet);

Set unionSet = Sets.union(setA, setB);
assertEquals(setOf(1,2,3,4,6,8), unionSet);

Взгляните на нашу статью о наборах гуавы, чтобы узнать больше.

5.3. Коллекции Apache Commons

Теперь давайте использовать статические методы intersection и union класса SetUtils из коллекций Apache Commons:

Set intersectSet = SetUtils.intersection(setA, setB);
assertEquals(setOf(2,4), intersectSet);

Set unionSet = SetUtils.union(setA, setB);
assertEquals(setOf(1,2,3,4,6,8), unionSet);

Чтобы узнать больше, ознакомьтесь с нашим учебником по Apache Commons Collections SetUtils.

6. Заключение

Мы видели обзор того, как выполнять некоторые основные операции с наборами, а также подробную информацию о том, как реализовать эти операции различными способами.

Все примеры кода можно найти на GitHub .

Теория множеств – крайне важная математическая концепция для любых разработчиков. Данные, с которыми работают программы, часто представляются как множества, а значит к ним применимы правила теории множеств. В первую очередь это касается различных операций над множествами, например, пересечения или объединения.

Это не значит, что нужно знать эту теорию от и до. Напротив, достаточно изучить ее основные понятия и некоторые операции. Этого хватит для эффективного решения подавляющего числа задач. Сама теория множеств относится к интуитивно понятным концепциям. Она хорошо ложится на здравый смысл и понятна людям даже без особой математической подготовки.

Краткая терминология

Основное понятие теории множеств, как не удивительно — множество. Множеством обозначают набор объектов произвольной природы, рассматривающихся как единое целое. Простейший пример — цифры. Множество всех цифр включает в себя 10 элементов (от 0 до 9).

Но не каждый набор объектов можно назвать множеством. Существует важное условие – все элементы множества должны быть уникальными. Например, числа 1, 1 и 3 не могут называться множеством, а 1, 3, 5 могут.

Множества между собой могут находиться в определенных отношениях. Например, множество натуральных чисел является подмножеством целых чисел, которые в свою очередь являются подмножеством рациональных чисел и так далее. Понятие «подмножество» означает, что все элементы одного множества также входят в другое множество, называемое надмножеством.

Представление множеств кружками довольно удобно. Можно быстро оценить как друг с другом соотносятся разные множества.

Но математические объекты, такие как числа, не единственные возможные объекты множеств. Множеством можно назвать группу людей, стоящих на остановке в ожидании своего автобуса, или жильцов квартир одного дома, города или страны.

Операции над множествами

На практике, представление данных в виде множеств полезно тогда, когда мы хотим что-то сделать с ними. Простой пример. Когда в Фейсбуке вы заходите на страницу другого человека, то Фейсбук показывает вам блок с общими друзьями. Если принять, что ваши друзья и друзья вашего друга — два множества, то общие друзья — множество, полученное как пересечение исходных множеств друзей.

Пересечение — один из ярких примеров операции над множествами, которая в программировании встречается повсеместно. То же самое можно сказать и о некоторых других операциях. Важно, что результатом всех этих операций являются множества, а значит они подчиняются тем же правилам, что и исходные множества. Например, сохраняется уникальность элементов.

В Java нет встроенных методов для работы с массивами как со множествами. Поэтому мы написали свою библиотеку для демонстрации. Ниже примеры показаны на ней

Пересечение

Пересечением множеств называется множество, в которое входят элементы, встречающиеся во всех данных множествах одновременно.

Пример с общими друзьями:

import io.hexlet.utils.ArraysAsSets;

// Друзья одного человека
String[] friends1 = {"vasya", "kolya", "petya"};

// Друзья другого человека
String[] friends2 = {"igor", "petya", "sergey", "vasya", "sasha"};

// Общие друзья
ArraysAsSets.intersection(friends1, friends2);
// ["vasya", "petya"]

Объединение

Объединением множеств называется множество, в которое входят элементы всех данных множеств.

String[] friends1 = {"vasya", "kolya", "petya"};
String[] friends2 = {"igor", "petya", "sergey", "vasya", "sasha"};

ArraysAsSets.union(friends1, friends2);
// ["vasya", "kolya", "petya", "igor", "sergey", "sasha"]

Каждый друг в объединении встречается ровно один раз.

Дополнение (разность)

Разностью двух множеств называется множество, в которое входят элементы первого множества, не входящие во второе. В программировании такая операция часто называется diff (разница).

String[] friends1 = {"vasya", "kolya", "petya"};
String[] friends2 = {"igor", "petya", "sergey", "vasya", "sasha"};

Оригинальная статьяhttps://www.cnblogs.com/wanyong-wy/p/7721978.html

Реализуйте основную используемую коллекцию Set.Особенность коллекции Set состоит в том, что элементы в коллекции не могут повторяться.

Как насчет конкретного кода:

import java.util.HashSet;
import java.util.Set;
 
public class Test {
    public static void main(String[] args) {
        Set<Integer> result = new HashSet<Integer>();
         
        Set<Integer> set1 = new HashSet<Integer>();
         
        Set<Integer> set2 = new HashSet<Integer>();
         
        set1.add(11);
        set1.add(22);
        set1.add(333);
        set1.add(4);
         
        set2.add(22);
        set2.add(333);
        set2.add(1);
         
        System.out.println("set1 = "+set1.toString());
        System.out.println("set2 = "+set2.toString());
         
        result.clear();
        result.addAll(set1);
        result.retainAll(set2);
        System.out.println ("Пересечение =" + результат);
         
        result.clear();
        result.addAll(set1);
        result.removeAll(set2);
                 System.out.println ("Набор различий =" + результат);
         
        result.clear();
        result.addAll(set1);
        result.addAll(set2);
                 System.out.println ("Союз =" + результат);
    }
}