import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        // HashSet
        Set<String> hashSet = new HashSet<>();
        boolean added1 = hashSet.add("Яблоко");  // true
        boolean added2 = hashSet.add("Яблоко");  // false (дубликат)
        System.out.println(hashSet);  // [Яблоко]

        // LinkedHashSet
        Set<String> linkedSet = new LinkedHashSet<>();
        linkedSet.add("Яблоко");
        linkedSet.add("Банан");
        linkedSet.add("Яблоко");  // false
        System.out.println(linkedSet);  // [Яблоко, Банан] — порядок вставки

        // TreeSet
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(5);
        treeSet.add(1);
        treeSet.add(5);  // false
        System.out.println(treeSet);  // [1, 5] — отсортировано
    }
}

Вывод показывает уникальность и особенности каждой реализации.

import 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("Банан");

        boolean removed1 = fruits.remove("Яблоко");  // true
        boolean removed2 = fruits.remove("Апельсин");  // false (не найден)

        System.out.println(fruits);  // [Банан]
    }
}

Аналогично для других реализаций: В TreeSet remove сохраняет сортировку.

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

public class Main {
    public static void main(String[] args) {
        Set<String> fruits = new HashSet<>();
        fruits.add("Яблоко");

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

// Упрощенная логика расширения
private void ensureCapacity(int minCapacity) {
    if (minCapacity > elementData.length) {
        int newCapacity = elementData.length + (elementData.length >> 1); // Увеличение на 50%
        if (newCapacity < minCapacity) {
            newCapacity = minCapacity;
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}
Эта стратегия гарантирует, что хотя отдельные операции добавления могут быть дорогими (при необходимости расширения), средняя стоимость большого количества операций добавления остается O(1).

System.arraycopy(elementData, index, elementData, index + 1, size - index);