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

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]

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

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