private transient HashMap<E,Object> map;

// Заглушка значения для всех ключей
private static final Object PRESENT = new Object();

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();

        // Добавление элементов
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");

        // Попытка добавить дубликат
        boolean isAdded = set.add("Apple"); // Вернет false, так как "Apple" уже существует

        // Вывод элементов
        for (String fruit : set) {
            System.out.println(fruit);
        }
    }
}

HashSet<String> set = new HashSet<>();
boolean added = set.add("Apple"); // Возвращает true
added = set.add("Apple"); // Возвращает false, так как элемент уже существует

boolean removed = set.remove("Apple"); // Возвращает true, если "Apple" был удален
removed = set.remove("Banana"); // Возвращает false, если "Banana" не был в наборе

boolean exists = set.contains("Apple"); // Возвращает true, если "Apple" присутствует

boolean isEmpty = set.isEmpty(); // Проверка, пуст ли набор

int size = set.size(); // Получение размера набора

set.clear(); // Очищает набор

Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

String[] words = {"apple", "banana", "apple", "orange", "banana"};
HashSet<String> uniqueWords = new HashSet<>(Arrays.asList(words));

System.out.println(uniqueWords); // Вывод: [apple, banana, orange]

HashSet<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4));
HashSet<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5, 6));

// Объединение
set1.addAll(set2);
System.out.println("Union: " + set1); // Вывод: Union: [1, 2, 3, 4, 5, 6]

// Пересечение
set1.retainAll(set2);
System.out.println("Intersection: " + set1); // Вывод: Intersection: [3, 4]

// Разность
set1.removeAll(set2);
System.out.println("Difference: " + set1); // Вывод: Difference: [1, 2]

HashSet<String> emails = new HashSet<>();
String newEmail = "user@example.com";

if (!emails.add(newEmail)) {
    System.out.println("Этот email уже используется!");
} else {
    System.out.println("Email добавлен.");
}

javaimport java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> fruits = new HashSet<>();
        fruits.add("Яблоко");
        fruits.add("Банан");
        fruits.add("Яблоко");  // Игнорируется

        System.out.println(fruits.contains("Банан"));  // true
        fruits.remove("Яблоко");

        for (String fruit : fruits) {
            System.out.println(fruit);  // Порядок непредсказуем, например: Банан
        }
    }
}

Вывод: contains вернет true, размер 1 после удаления, порядок случайный.

javaimport java.util.LinkedHashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> fruits = new LinkedHashSet<>();
        fruits.add("Яблоко");
        fruits.add("Банан");
        fruits.add("Апельсин");

        for (String fruit : fruits) {
            System.out.println(fruit);  // Яблоко, Банан, Апельсин — порядок вставки
        }
    }
}

Вывод: Элементы в том порядке, в котором добавлены.

javaimport java.util.TreeSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> numbers = new TreeSet<>();
        numbers.add(5);
        numbers.add(1);
        numbers.add(3);

        for (Integer num : numbers) {
            System.out.println(num);  //отсортировано
        }

        // С Comparator для обратного порядка
        Set<Integer> reverseNumbers = new TreeSet<>((a, b) -> b - a);
        reverseNumbers.add(5);
        reverseNumbers.add(1);
        reverseNumbers.add(3);
        System.out.println(reverseNumbers);  // [5, 3, 1]
    }
}

Вывод: Элементы всегда отсортированы.

javaimport java.util.ArrayList;
import java.util.List;
import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<String> duplicates = new ArrayList<>();
        duplicates.add("Яблоко");
        duplicates.add("Банан");
        duplicates.add("Яблоко");

        Set<String> unique = new HashSet<>(duplicates);
        System.out.println(unique);  // [Банан, Яблоко]

        // С сохранением порядка
        Set<String> orderedUnique = new LinkedHashSet<>(duplicates);
        System.out.println(orderedUnique);  // [Яблоко, Банан]
    }
}

Вывод: Уникальные элементы, без дубликатов.

javaimport java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> users = new HashSet<>();
        users.add("user1");

        if (users.contains("user2")) {
            System.out.println("Пользователь существует");
        } else {
            users.add("user2");
            System.out.println("Новый пользователь добавлен");
        }

        if (!users.add("user1")) {
            System.out.println("Дубликат не добавлен");  // add возвращает false
        }
    }
}

Вывод: Проверка и добавление без дубликатов.