Гарантирует ли уникальность интерфейс Set?

# Гарантирует ли уникальность интерфейс Set?

Да, интерфейс Set ГАРАНТИРУЕТ уникальность элементов. Это его основное определяющее свойство. Set — это коллекция, которая не содержит дублирующихся элементов.

Что гарантирует Set?

Из документации Java:

A collection that contains no duplicate elements.

Это значит, что:

• Каждый элемент может присутствовать только один раз
• Попытка добавить существующий элемент не будет успешной
• Два элемента считаются одинаковыми, если equals() вернул true

Интерфейс Set

public interface Set<E> extends Collection<E> {
    // Определение методов
    boolean add(E e);           // Добавить элемент
    boolean remove(Object o);   // Удалить элемент
    boolean contains(Object o); // Проверить наличие
    Iterator<E> iterator();     // Итератор
    int size();                 // Размер
    // ...
}

Метод add() возвращает boolean:

• true — элемент был добавлен (его не было)
• false — элемент уже существовал (добавление проигнорировано)

Set<String> fruits = new HashSet<>();

boolean added1 = fruits.add("apple");   // true (добавлен)
boolean added2 = fruits.add("banana");  // true (добавлен)
boolean added3 = fruits.add("apple");   // false (уже существует!)

System.out.println(fruits.size()); // 2, не 3
System.out.println(fruits);        // [apple, banana]

Как Set обеспечивает уникальность?

Механизм зависит от конкретной реализации Set, но все используют equals() и hashCode().

HashSet — использует хеш-таблицу

Set<String> set = new HashSet<>();
set.add("Alice");   // hashCode("Alice") → hash1
set.add("Bob");     // hashCode("Bob") → hash2
set.add("Alice");   // hashCode("Alice") → hash1, но equals() = true, не добавляется

System.out.println(set);     // [Alice, Bob]
System.out.println(set.size()); // 2

Процесс:

1. Вычисляется hashCode элемента
2. Проверяются элементы в соответствующей hash-ячейке
3. Если элемент с тем же hashCode и equals() = true найден, добавление игнорируется
4. Иначе элемент добавляется

TreeSet — использует красно-чёрное дерево

Set<String> set = new TreeSet<>();
set.add("Charlie");
set.add("Alice");
set.add("Charlie");  // Сравнивается через compareTo(), не добавляется

System.out.println(set);     // [Alice, Charlie]
System.out.println(set.size()); // 2

Процесс:

1. Элементы сравниваются через compareTo() или Comparator
2. Если элемент равен существующему (compareTo() = 0), добавление игнорируется
3. Элементы хранятся в отсортированном виде

LinkedHashSet — использует хеш-таблицу с порядком вставки

Set<String> set = new LinkedHashSet<>();
set.add("C");
set.add("A");
set.add("B");
set.add("A");  // Не добавляется

System.out.println(set);     // [C, A, B] (в порядке вставки)
System.out.println(set.size()); // 3, а не 4

Пример с собственным классом

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    
    @Override
    public String toString() {
        return "Person{" + name + ", " + age + "}";
    }
}

// Использование в Set
Set<Person> people = new HashSet<>();

Person p1 = new Person("Alice", 30);
Person p2 = new Person("Alice", 30);  // Одинаковые данные, разные объекты
Person p3 = new Person("Bob", 25);

people.add(p1);  // true (добавлен)
people.add(p2);  // false (p1.equals(p2) = true, не добавляется!)
people.add(p3);  // true (добавлен)

System.out.println(people.size()); // 2, не 3!
System.out.println(people);        // [Person{Alice, 30}, Person{Bob, 25}]

Если забыть переопределить equals() и hashCode():

public class BadPerson {
    public String name;
    public int age;
    
    public BadPerson(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // equals() и hashCode() НЕ переопределены
}

// Проблема
Set<BadPerson> people = new HashSet<>();
BadPerson p1 = new BadPerson("Alice", 30);
BadPerson p2 = new BadPerson("Alice", 30);

people.add(p1);  // true
people.add(p2);  // true (!!!) — ДОБАВЛЯЕТСЯ, потому что это разные объекты

System.out.println(people.size()); // 2 (неправильно!)
// Set не может гарантировать уникальность без корректного equals()

Различные реализации Set

Проверка уникальности

Set<String> set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("apple");

// Проверить, был ли элемент добавлен
if (set.contains("apple")) {
    System.out.println("Set содержит уникальный apple");
}

// Использование в цикле
for (String fruit : set) {
    System.out.println(fruit); // apple, banana (без дубликатов)
}

Практический пример: Удаление дубликатов

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);

// HashSet автоматически удалит дубликаты
Set<Integer> unique = new HashSet<>(numbers);

System.out.println(unique);     // [1, 2, 3, 4]
System.out.println(unique.size()); // 4

// Если нужен список без дубликатов
List<Integer> uniqueList = new ArrayList<>(unique);
System.out.println(uniqueList); // [1, 2, 3, 4]

Потокобезопасность

Обычные реализации Set НЕ потокобезопасны:

Set<String> set = new HashSet<>();  // НЕ потокобезопасен

// Если использовать в нескольких потоках, будут проблемы
Thread t1 = new Thread(() -> set.add("A"));
Thread t2 = new Thread(() -> set.add("B"));

// Для потокобезопасности:
Set<String> syncSet = Collections.synchronizedSet(new HashSet<>());

Вывод

ДА, интерфейс Set ГАРАНТИРУЕТ уникальность элементов. Это его основное назначение. Гарантия работает через:

1. HashSet — hashCode() и equals()
2. TreeSet — compareTo() и Comparator
3. LinkedHashSet — hashCode(), equals() и порядок вставки

Ключный момент: уникальность основана на equals(), а не на идентичности объектов (==). Два разных объекта с одинаковыми данными будут считаться одним элементом в Set.