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

import java.util.*;

public class Task131025 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        
        String s1 = "Hello";
        String s2 = new String("Hello");
        String s3 = s2.intern();
        
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.remove(s1);
        set.remove(s3);
        
        System.out.println(set.size());
        System.out.println(set.contains("Hello"));
    }
}

import reactor.core.scheduler.Schedulers;

Schedulers.parallel(); // Готов к использованию

Schedulers не создают потоки заранее — ленивые, как Mono/Flux.

import reactor.core.publisher.Flux;
import java.time.Duration;

Flux<Integer> flux = Flux.range(1, 3)
    .map(i -> { // На subscribeOn
        System.out.println("Map1 на потоке: " + Thread.currentThread().getName());
        return i * 10;
    })
    .publishOn(Schedulers.boundedElastic()) // Переключаем downstream
    .delayElements(Duration.ofSeconds(1)) // На boundedElastic
    .map(i -> { // На boundedElastic
        System.out.println("Map2 на потоке: " + Thread.currentThread().getName());
        return i + 1;
    });

flux.subscribeOn(Schedulers.single()) // Upstream на single
    .subscribe(System.out::println);

Вывод покажет: Map1 на "single-1", delay и Map2 на "boundedElastic-X". Это асинхронно: основной поток не блокируется.

Flux.range(1, 10)
    .flatMap(i -> Mono.just(i).delayElement(Duration.ofMillis(100)), 2) // Max 2 параллельно
    .subscribeOn(Schedulers.parallel())
    .blockLast(); // Для теста, в prod не блокируйте!

Это ограничивает: не 10 задержек сразу, а по 2.