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

import java.util.HashSet;

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

        set.add("apple");
        set.add("banana");
        set.add("orange");
        set.add("apple");
        set.add("grape");

        set.remove("banana");
        set.add("pear");

        System.out.println("Set size: " + set.size());

        if (set.contains("orange")) {
            set.remove("orange");
            set.add("orange");
        }

        for (String fruit : set) {
            System.out.print(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 добавлен.");
}

public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, Serializable {
    private transient LinkedHashMap<E, Object> map;

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

    public LinkedHashSet() {
        map = new LinkedHashMap<>();
    }

    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }
}

LinkedHashSet<String> linkedSet = new LinkedHashSet<>();
linkedSet.add("Apple");
linkedSet.add("Banana");
linkedSet.add("Orange");

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

public class Main {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("apple");
        set.add("orange");
        set.add("banana");
        
        for (String s : set) {
            System.out.print(s + " ");
        }
    }
}

LinkedHashSet<String> set = new LinkedHashSet<>();
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());
}

LinkedHashSet<String> clonedSet = (LinkedHashSet<String>) set.clone();

LinkedHashSet<String> orderedSet = new LinkedHashSet<>();
orderedSet.add("One");
orderedSet.add("Two");
orderedSet.add("Three");
orderedSet.add("Two"); // Дубликат будет проигнорирован

for (String item : orderedSet) {
    System.out.println(item);
}
// Вывод будет в порядке вставки: One, Two, Three

LinkedHashSet<String> cache = new LinkedHashSet<>();
cache.add("Page1");
cache.add("Page2");
cache.add("Page3");

if (cache.size() > 2) {
    String first = cache.iterator().next();
    cache.remove(first);
}

cache.add("Page4");

System.out.println(cache);
// Вывод: [Page2, Page3, Page4]

List<String> listWithDuplicates = Arrays.asList("a", "b", "c", "a", "b");
LinkedHashSet<String> uniqueSet = new LinkedHashSet<>(listWithDuplicates);

System.out.println(uniqueSet); // Вывод: [a, b, c]

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("Apple");
        treeSet.add("Banana");
        treeSet.add("Cherry");

        System.out.println(treeSet);
    }
}

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        set.add(5);
        set.add(2);
        set.add(10);
        set.add(7);
        set.add(2);
        set.add(7);
        
        for (Integer i : set) {
            System.out.print(i + " ");
        }
    }
}

import java.util.TreeSet;

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

        System.out.println("Наименьший элемент: " + numbers.first());
        System.out.println("Наибольший элемент: " + numbers.last());
        System.out.println("Наибольший элемент, меньший 10: " + numbers.lower(10));
    }
}
Вывод:
Наименьший элемент: 1
Наибольший элемент: 10
Наибольший элемент, меньший 10: 5

import java.util.TreeSet;

public class TreeSetSubSetExample {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("Apple");
        treeSet.add("Banana");
        treeSet.add("Cherry");
        treeSet.add("Date");
        treeSet.add("Fig");

        System.out.println("Поднабор до 'Cherry': " + treeSet.headSet("Cherry"));
        System.out.println("Поднабор от 'Banana': " + treeSet.tailSet("Banana"));
    }
}
Вывод:
Поднабор до 'Cherry': [Apple, Banana]
Поднабор от 'Banana': [Banana, Cherry, Date, Fig]