var list = Arrays.asList(1, 2, 3, 3, 4, 5, 5);
var distinctList = list.stream()
                       .distinct()
                       .collect(Collectors.toList());
// distinctList: [1, 2, 3, 4, 5]

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public class ProjectReactorExample {
    public static void main(String[] args) {
        // Пример с Mono
        Mono<String> monoExample = Mono.just("Hello, Reactor!");
        monoExample
            .map(String::toUpperCase) // Преобразуем строку в верхний регистр
            .subscribe(System.out::println); // Подписываемся и выводим результат

        // Пример с Flux
        Flux<Integer> fluxExample = Flux.just(1, 2, 3, 4, 5);
        fluxExample
            .filter(num -> num % 2 == 0) // Фильтруем четные числа
            .map(num -> num * num) // Возводим в квадрат
            .subscribe(System.out::println); // Подписываемся и выводим результат
    }
}

import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class SpELExample {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();

        // Пример вычисления простого выражения
        String expression = "'Hello, Spring SpEL!'.toUpperCase()";
        String result = parser.parseExpression(expression).getValue(String.class);

        System.out.println(result); // Вывод: HELLO, SPRING SPEL!
    }
}

@Component
public class MyBean {
    @Value("#{T(java.lang.Math).random() * 100}")
    private double randomValue;

    @Value("#{systemProperties['user.name']}")
    private String userName;

    public void printValues() {
        System.out.println("Random Value: " + randomValue);
        System.out.println("User Name: " + userName);
    }
}

import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

import java.util.Arrays;
import java.util.List;

public class CollectionExample {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Фильтрация списка
        List<Integer> filteredNumbers = (List<Integer>) parser.parseExpression(
                "#numbers.?[#this > 2]").getValue(new StandardEvaluationContext(), numbers);

        System.out.println(filteredNumbers); // Вывод: [3, 4, 5]
    }
}

import java.util.EnumMap;

enum Action {
    START, STOP, PAUSE
}

public class EnumMapExample {
    public static void main(String[] args) {
        EnumMap<Action, Runnable> actionMap = new EnumMap<>(Action.class);

        // Определяем поведение для каждого значения Enum
        actionMap.put(Action.START, () -> System.out.println("Starting the process..."));
        actionMap.put(Action.STOP, () -> System.out.println("Stopping the process..."));
        actionMap.put(Action.PAUSE, () -> System.out.println("Pausing the process..."));

        // Пример вызова
        Action currentAction = Action.START;
        actionMap.get(currentAction).run();
    }
}

 java
import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapExample {
    public static void main(String[] args) {
        Map<String, String> map = new IdentityHashMap<>();

        String key1 = new String("key");
        String key2 = new String("key");

        map.put(key1, "Value 1");
        map.put(key2, "Value 2");

        System.out.println(map); // Выведет обе пары: {key=Value 1, key=Value 2}
    }
}

 java
import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        WeakHashMap<Object, String> map = new WeakHashMap<>();

        Object key = new Object();
        map.put(key, "Value");

        System.out.println("Before GC: " + map); // Ключ и значение есть

        key = null; // Убираем сильную ссылку на объект
        System.gc(); // Вызываем сборку мусора

        System.out.println("After GC: " + map); // Ключ и значение исчезли
    }
}

 java
import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new LinkedHashMap<>();
        
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        
        System.out.println(map); // {1=One, 2=Two, 3=Three}
    }
}

 java
import java.util.LinkedHashMap;
import java.util.Map;

public class LRUExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new LinkedHashMap<>(16, 0.75f, true);

        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");

        map.get(2); // Используем ключ 2
        System.out.println(map); // {1=One, 3=Three, 2=Two}
    }
}

@Override
protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
    return size() > 3; // Удалять записи, если их больше 3
}

import java.util.concurrent.CompletableFuture;

public class AsyncExample {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            sleep(2000);
            return "Результат задачи 1";
        });

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            sleep(3000);
            return "Результат задачи 2";
        });

        CompletableFuture<String> combined = task1.thenCombine(task2, (result1, result2) -> result1 + " & " + result2);

        // Ожидаем завершения всех задач и получаем общий результат
        combined.thenAccept(result -> {
            long endTime = System.currentTimeMillis();
            System.out.println("Общий результат: " + result);
            System.out.println("Время выполнения: " + (endTime - startTime) + " мс");
        });

        combined.join(); // Дождёмся завершения наших задач
    }

    private static void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;

public class WalkFileTreeExample {
    public static void main(String[] args) throws IOException {
        Path startPath = Paths.get("example_directory");

        Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println("Deleting file: " + file);
                Files.delete(file); // Удаляем файл
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                System.out.println("Deleting directory: " + dir);
                Files.delete(dir); // Удаляем директорию после удаления её содержимого
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

import java.util.List;
import java.util.stream.Collectors;

public class TeeingExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        var result = numbers.stream().collect(
            Collectors.teeing(
                Collectors.summingInt(Integer::intValue), // Первая операция: сумма
                Collectors.averagingInt(Integer::intValue), // Вторая операция: среднее
                (sum, avg) -> "Sum: " + sum + ", Average: " + avg // Объединение результатов
            )
        );

        System.out.println(result); // Вывод: Sum: 15, Average: 3.0
    }
}