⚡️ Reactive Streams в Java — WebFlux + Project Reactor

Когда у тебя миллион запросов и сервер начинает задыхаться — обычный Spring MVC с потоками умирает. Тут выходит на сцену Spring WebFlux и движок Project Reactor. Асинхронщина, backpressure, и код, который реально дышит под нагрузкой.

📦 Подключаем WebFlux в pom.xml:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

➡️ Всё. Теперь у тебя вместо старого DispatcherServlet — реактивный движок Netty.

🧠 Минимальный контроллер на WebFlux:

@RestController
public class HelloController {
    @GetMapping("/hello")
    public Mono<String> hello() {
        return Mono.just("👋 Привет, реактивный мир!");
    }
}

➡️ Mono = 0..1 значение (как Future). Flux = поток значений.

📛 Пример со стримом чисел:

@GetMapping("/numbers")
public Flux<Integer> numbers() {
    return Flux.range(1, 5).delayElements(Duration.ofSeconds(1));
}

➡️ Клиент получает числа по одному каждую секунду. Не JSON сразу, а настоящий поток.

🔄 Реактивные операторы (Project Reactor):

Flux.just("A", "B", "C")
    .map(s -> s.toLowerCase())
    .filter(s -> !s.equals("b"))
    .subscribe(System.out::println);

➡️ Конвейер: map → filter → подписка. Реактивщина — это не if’ы и for, а цепочки.

💥 Backpressure — контроль нагрузки:

Flux.interval(Duration.ofMillis(10))
    .onBackpressureDrop()
    .subscribe(i -> System.out.println("⚡️ " + i));

➡️ Если потребитель не успевает — лишние данные отбрасываются. Ты управляешь потоком, а не он тобой.

🔐 Интеграция с БД через R2DBC:

@Repository
public interface UserRepo extends ReactiveCrudRepository<User, String> {}

@GetMapping("/users")
public Flux<User> getUsers() {
    return userRepo.findAll();
}

➡️ Даже база работает реактивно. Никаких блокировок потоков.

Чем отличается WebFlux 🆚 Project Reactor?

👍 Project Reactor = библиотека реактивных стримов (Mono, Flux, операторы).
👍 WebFlux = фреймворк на базе Reactor, чтобы писать контроллеры, API и сервисы.

📚 Документация:

👉 Reactor 👈

👉 WebFlux 👈

🗣️ Запомни: Reactive Streams — это не магия ради хайпа. Это способ выжить под нагрузкой, где обычный синхронный код падает. Если хочешь сервер, который тащит десятки тысяч соединений — без WebFlux и Reactor ты уже динозавр.

☕️ Массивы данных. Одномерные и многомерные массивы

В этом видео разбираются основы работы с массивами в Java. Автор показывает, как создавать и использовать одномерные и многомерные массивы, как обращаться к их элементам и перебирать данные. Это базовый инструмент, без которого невозможно работать с большими наборами информации.

🤩 Java Фишки и трюки || #Видео

🧹 Advanced GC Tuning — ZGC в Java

Если ты думаешь, что GC — это просто «собрал мусор и пошёл дальше», то добро пожаловать в ад продакшена с кучей тредов и 200 ГБ heap’а.
Обычный GC может стопнуть мир на секунду — и твой сервис превращается в «слайдшоу». Для маркетплейса или финтеха — смерть.
Тут на сцену выходит ZGC — сборщик мусора, который обещает паузы меньше 1 мс, даже на огромных хипах.

📦 Как включить ZGC

Запускаешь Java-приложение с флагами:

java -XX:+UseZGC -Xmx16g -Xms16g -jar app.jar

➡️ -XX:+UseZGC активирует Z Garbage Collector.
➡️ Работает начиная с JDK 11 (продакшен-стабил с 15).

🧠 В чём магия ZGC?

Обычный GC работает так: стопнул мир → пересобрал кучу → отпустил.
ZGC же:

🟢 Делает конкурентную маркировку и компактификацию (почти весь GC идёт параллельно с твоим кодом).
🟢 Использует цветные указатели (colored pointers), чтобы отслеживать состояние объектов.
🟢 Работает без длинных стопов — паузы \~0.5–2 мс даже при 100+ ГБ heap.

➡️ Идеален для real-time систем, API с миллионами RPS, финансовых транзакций.

⚙️ Настройки для тюнинга

Базовые:

-XX:+UseZGC
-XX:ZUncommitDelay=300
-XX:SoftMaxHeapSize=12g

🟢 ZUncommitDelay — через сколько секунд освобождать неиспользуемую память (по умолчанию 300).
🟢 SoftMaxHeapSize — мягкий лимит кучи (GC будет стараться держаться в нём, даже если Xmx больше).

Мониторинг:

-XX:+UnlockDiagnosticVMOptions -XX:+PrintGC -Xlog:gc*:gc.log

➡️ Логи GC покажут, как часто идут паузы и сколько памяти реально отжимается.


🔍 Пример GC-лога с ZGC

[2.345s][info][gc,start    ] GC(0) Pause Mark Start
[2.345s][info][gc          ] GC(0) Concurrent Mark
[2.348s][info][gc          ] GC(0) Pause Mark End 0.2ms
[2.349s][info][gc          ] GC(0) Concurrent Relocate

➡️ Видишь? Паузы меньше миллисекунды, всё остальное уходит в concurrent.

Когда брать ZGC, а когда нет

🟢 Бери:

🟢 У тебя огромные хипы (16–500 ГБ).
🟢 Важны низкие latency (игры, трейдинг, API).
🟢 Ты не хочешь тратить дни на ручной тюнинг старых GC.

🔴 Не бери:

🟢Если у тебя микросервис на 512 МБ heap (Overkill).
🟢Если нужен максимальный throughput (G1 иногда быстрее на маленьких heap’ах).

🗣️ Запомни:Он не делает чудес — память всё равно надо оптимизировать, но он гарантирует, что GC-паузы не убьют твой SLA.

☕️ Коллекции в Джава (Collections Framework)

В этом видео автор подробно объясняет, как работает Collections Framework в Java.
Пошагово демонстрируются основные интерфейсы и реализации: List, Set, Map, а также важные классы вроде ArrayList, HashSet, HashMap. Показано, как правильно выбирать подходящую коллекцию, когда использовать список, а когда — отображение, как добавлять, удалять и перебирать элементы.

🤩 Java Фишки и трюки || #Видео

⚡️ Reactive Streams: поток вместо цикла — и это работает

В обычном Java-коде всё блокируется: запрос ждёт ответ, поток простаивает.
В реактивщине (Spring WebFlux) — данные текут как река.
Ты подписался на поток → получил элементы по мере готовности.


📛 Пример: возвращаем поток данных

import reactor.core.publisher.Flux;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/users")
    public Flux<String> getUsers() {
        return Flux.just("Alice", "Bob", "Charlie");
    }
}

➡️ Не List, а Flux.
Клиент получит поэлементно: Alice → Bob → Charlie.

🔄 Mono vs Flux

👍 Mono<T> → 0..1 элемент
👍 Flux<T> → 0..N элементов

@GetMapping("/user")
public Mono<String> getUser() {
    return Mono.just("Alice");
}

➡️ Реактивщина различает одиночный результат и поток.

🧪 Преобразования прямо в цепочке

Flux.range(1, 5)
    .map(i -> i * 2)
    .filter(i -> i > 5)
    .subscribe(System.out::println);

➡️ Поток как коллекция, но лениво и неблокирующе.

📦 Асинхронные запросы

@GetMapping("/external")
public Mono<String> callApi(WebClient client) {
    return client.get()
                 .uri("https://api.example.com/data")
                 .retrieve()
                 .bodyToMono(String.class);
}

➡️ Без блокировок. Пока API думает — поток свободен для других задач.

🔗 Комбинация потоков

Mono<String> u1 = Mono.just("Alice");
Mono<String> u2 = Mono.just("Bob");

Flux<String> merged = Flux.merge(u1, u2);

➡️ Потоки объединяются — результат приходит как готов.

👀 Backpressure (контроль скорости)

Publisher шлёт данные → Subscriber сам говорит, сколько готов принять.
Нет перегрузки, система держится даже при большом потоке событий.

🗣️ Запомни: Не блокируйся на ожидании. Подписывайся, фильтруй и трансформируй.

ZGC 🆚 Shenandoah — битва без стоп-пауз

Java в 2025 уже умеет два монстра low-latency GC: ZGC и Shenandoah.
Оба обещают микросекундные паузы даже на кучах в сотни гигабайт.
Но у каждого свой характер. Давай разберёмся.

📦 Запуск

ZGC (JDK 15+):

java -XX:+UseZGC -Xmx16g -Xms16g -jar app.jar

Shenandoah (JDK 12+, лучше JDK 17+):

java -XX:+UseShenandoahGC -Xmx16g -Xms16g -jar app.jar

➡️ Оба вкл/выкл одним флагом.

🧠 Архитектура под капотом

🔵 ZGC:

🟢Использует colored pointers (цветные указатели в 64-битных адресах).
🟢Разносит паузы на микросекундные stop-the-world (STW).
🟢Очень простая логика: mark → relocate, всё конкурентно.

🔴 Shenandoah:

🟢Делает concurrent compacting: сжимает кучу без паузы.
🟢Использует brooks pointers (доп. уровень индирекции → каждый объект указывает на forwarder).
🟢Чуть медленнее из-за этой индирекции, но тоже держит паузы \~<10мс.

⚙️ Пример приложения для сравнения

import java.util.ArrayList;
import java.util.List;

public class StressTest {
    public static void main(String[] args) {
        List<byte[]> list = new ArrayList<>();
        while (true) {
            for (int i = 0; i < 100; i++) {
                list.add(new byte[1024 * 1024]); // 100MB
            }
            if (list.size() > 2000) list.clear(); // держим heap живым
        }
    }
}

📊 Запускаем и смотрим логи

🔵 ZGC (-XX:+UseZGC -Xlog:gc*):

[2.345s][info][gc] GC(7) Pause Mark Start 0.2ms
[2.345s][info][gc] GC(7) Pause Mark End 0.1ms
[2.346s][info][gc] GC(7) Concurrent Relocate 45.6ms

➡️ Паузы \~0.1–0.3 мс. Основная работа уходит в «Concurrent Relocate», но это в фоне.

🔴 Shenandoah (-XX:+UseShenandoahGC -Xlog:gc*):

[2.456s][info][gc] Pause Init Mark 1.2ms
[2.457s][info][gc] Concurrent Mark 38.9ms
[2.496s][info][gc] Pause Final Evac 1.5ms

➡️ Паузы больше (1–2 мс), но всё ещё очень маленькие.


🧪 Реальные различия (TL;DR)

Характеристика        | ZGC 🟢                       | Shenandoah 🔴
--------------------  | ---------------------------- | ----------------------------
⏱️ Паузы (latency)   | ~0.2–2 мс (супер-стабильно) | ~1–10 мс (чуть длиннее)
⚡️ Throughput        | Чуть выше (нет индирекции)  | Чуть ниже (Brooks ptr)
🗂 Heap size         | До 16 ТБ (!)                | Ограничен ~4–8 ТБ
🧩 Сложность         | Простая модель              | Более гибкий, но сложнее
🎯 Подходит для      | Trading, real-time API      | Крупные JVM-сервисы, где не критичны 2–3 мс

🎯 Выводы

👍 ZGC → если нужна ультра-низкая задержка (финтех, realtime). Работает предсказуемо.
👍 Shenandoah → если heap до пары терабайт и важнее гибкость (много опций тюнинга).

🗣️ Запомни: ZGC = хирург с лазером, точный и быстрый.Shenandoah = механик с инструментами, чуть дольше, но чинит даже сложные ситуации.В продакшене пробуй оба — профит зависит от нагрузки и архитектуры.

🧩 Sealed Classes — контроль наследования в Java

Java 17 принесла sealed classes — способ держать наследование под контролем. Больше никаких «кто угодно расширил класс и сделал фигню». Теперь ты сам решаешь, кто может быть наследником.

📦 Базовый sealed-класс

public sealed class Shape 
    permits Circle, Rectangle, Triangle {}

➡️ Только три класса могут расширять Shape.

🔑 Наследники обязаны выбрать модификатор

public final class Circle extends Shape {}
public non-sealed class Rectangle extends Shape {}
public sealed class Triangle extends Shape 
    permits Equilateral, Isosceles {}

🟢 final — тупик, дальше наследовать нельзя.
🟢 sealed — можно, но только по твоему списку.
🟢 non-sealed — снимает ограничения, разрешает наследование всем.

🧠 Идеально для switch

static String type(Shape s) {
    return switch (s) {
        case Circle c    -> "Окружность";
        case Rectangle r -> "Прямоугольник";
        case Triangle t  -> "Треугольник";
    };
}

➡️ Компилятор знает все варианты и не требует default. Ты не забудешь обработать новый тип.

🛠 Контроль API

public sealed interface Request 
    permits Login, Register, Ping {}

public final class Login implements Request {}
public final class Register implements Request {}
public final class Ping implements Request {}

➡️ Никто не добавит лишний «левый» запрос. Архитектура закрыта и прозрачна.


📚 Отличие от abstract

🟢abstract оставляет свободу: наследников сколько угодно.
🟢sealed фиксирует список: никакой самодеятельности.

➡️ Это не про обязательные методы, а про ограничение иерархии.

🧱 Комбо с record

public sealed interface Shape permits Circle, Rectangle {}

public record Circle(double r) implements Shape {}
public record Rectangle(double w, double h) implements Shape {}

➡️ Получаешь компактные immutable-модели и полную предсказуемость.


🗣️ Запомни: Используй в API, моделях и ролях, где важна безопасность и прозрачность.

🧪 Records с Validation: immutable данные с проверкой на входе

В Java record — это идеальный инструмент для работы с неизменяемыми объектами. Но часто нам нужно не просто хранить данные, а проверять их корректность при создании. Хорошая новость: в record это встроено прямо в конструктор.

🔒 Простая неизменяемость

public record User(String name, int age) {}

➡️ Все поля final, сеттеров нет, объект полностью immutable. Но можно передать хоть отрицательный возраст — компилятор не остановит.


⚖️ Валидация в compact-конструкторе

public record User(String name, int age) {
    public User {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Имя не может быть пустым");
        }
        if (age < 0) {
            throw new IllegalArgumentException("Возраст не может быть отрицательным");
        }
    }
}

➡️Такой конструктор автоматически вызывается при каждом new User(...), и данные сразу проверяются.

🛡 Гарантия на уровне модели

User u = new User("Иван", 25);   // ✅ всё ок
User bad = new User("", -5);     // ❌ IllegalArgumentException

➡️ Теперь ошибка «грязных данных» невозможна: объект даже не создастся.

🔄 Компактность vs. явный конструктор

Можно написать и полный конструктор:

public User(String name, int age) {
    if (age < 18) throw new IllegalArgumentException("Только 18+");
    this.name = name;
    this.age = age;
}

➡️ Но компактная форма предпочтительнее — она короче и сразу показывает, что мы в record.

📦 Валидация коллекций внутри record

public record Order(List<String> items) {
    public Order {
        if (items == null || items.isEmpty()) {
            throw new IllegalArgumentException("Заказ пуст");
        }
        items = List.copyOf(items); // защитная копия
    }
}

➡️ Даже список внутри immutable — теперь никто не сможет изменить заказ после создания.

🚦 Использование с аннотациями Bean Validation

public record Customer(
    @NotBlank String name,
    @Email String email
) {}

➡️Если подключён Hibernate Validator или Jakarta Validation, поля проверятся автоматически.


🧩 Кейс: «валидный объект» как контракт

public record Email(String value) {
    public Email {
        if (!value.matches("^[\\w.-]+@[\\w.-]+\\.[a-z]{2,}$")) {
            throw new IllegalArgumentException("Некорректный email");
        }
    }
}

➡️ Теперь в коде невозможно передать «плохую строку» туда, где нужен Email.


🗣️ Запомни: record — это не просто сокращённый POJO, а мощный способ гарантировать неизменяемость и корректность данных ещё при создании объекта.

☕️Основные концепции ООП

В этом видео автор знакомит с фундаментальными принципами объектно-ориентированного программирования (ООП) на примере Java. Объясняется, для чего нужно ООП и каковы его ключевые концепции, без глубокого вникания в код.

🤩 Java Фишки и трюки || #Видео

🔄 CompletableFuture + ExecutorService — сложные асинхронные цепочки

Java даёт мощный инструмент для работы с асинхронностью без сторонних библиотек — CompletableFuture вместе с ExecutorService. С их помощью можно строить цепочки вычислений, обрабатывать ошибки и настраивать таймауты.

⚡️ Запуск асинхронной задачи

ExecutorService executor = Executors.newFixedThreadPool(4);

CompletableFuture<String> future =
    CompletableFuture.supplyAsync(() -> {
        sleep(500);
        return "Результат";
    }, executor);

System.out.println(future.join()); // блокируемся и получаем результат
executor.shutdown();

➡️ supplyAsync запускает задачу в отдельном потоке из пула.

🔗 Построение цепочек

CompletableFuture<Integer> chain =
    CompletableFuture.supplyAsync(() -> 10)
        .thenApply(x -> x * 2)
        .thenApply(x -> x + 5);

System.out.println(chain.join()); // 25

➡️ Каждая операция обрабатывает результат предыдущей. Код становится декларативным.

🚦 Обработка ошибок

CompletableFuture<String> safe =
    CompletableFuture.supplyAsync(() -> {
        if (true) throw new RuntimeException("Ошибка");
        return "OK";
    }).exceptionally(ex -> "Fallback");

System.out.println(safe.join()); // Fallback

➡️ exceptionally позволяет задать запасной путь при сбое.

⏱️ Таймауты

CompletableFuture<String> future =
    CompletableFuture.supplyAsync(() -> {
        sleep(2000);
        return "Долго";
    });

String result = future.orTimeout(1, TimeUnit.SECONDS)
                      .exceptionally(ex -> "Таймаут")
                      .join();

System.out.println(result); // Таймаут

➡️ orTimeout прерывает выполнение, если задача не завершилась за указанное время.

🔀 Запуск нескольких задач

CompletableFuture<Integer> a = CompletableFuture.supplyAsync(() -> 1);
CompletableFuture<Integer> b = CompletableFuture.supplyAsync(() -> 2);

CompletableFuture<Integer> sum =
    a.thenCombine(b, Integer::sum);

System.out.println(sum.join()); // 3

➡️ thenCombine позволяет объединять результаты из разных потоков.

🎭 AnyOf и AllOf

CompletableFuture<Object> any =
    CompletableFuture.anyOf(a, b);

CompletableFuture<Void> all =
    CompletableFuture.allOf(a, b);

➡️ anyOf завершится, когда готов хотя бы один, allOf — когда готовы все.

🧩 ExecutorService как фундамент

Важно передавать свой ExecutorService в supplyAsync и runAsync. Иначе будет использоваться общий ForkJoinPool, который не всегда предсказуем.

🗣️ Запомни: CompletableFuture + ExecutorService дают асинхронность, цепочки и контроль ошибок прямо из коробки. Умение строить такие цепи позволяет писать быстрые и надёжные сервисы без Reactive или сторонних решений.

🛠 Memory-mapped Files — работа с файлами через ByteBuffer

Обычно мы читаем и пишем файлы через стандартные IO-потоки. Но у этого подхода есть потолок скорости. Memory-mapped files позволяют работать с файлами напрямую через память, минуя часть «лишних движений».

📂 Простое чтение через FileChannel

try (FileChannel channel = FileChannel.open(Path.of("data.txt"), StandardOpenOption.READ)) {
    MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
    while (buffer.hasRemaining()) {
        System.out.print((char) buffer.get());
    }
}

➡️ Файл как будто целиком «подмонтирован» в память, а чтение идёт напрямую через ByteBuffer.

💾 Запись в файл

try (FileChannel channel = FileChannel.open(Path.of("out.txt"),
        StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
    MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
    buffer.put("Hello world!".getBytes());
}

➡️ Любые изменения в буфере автоматически попадают в файл.

⚡ Работа с очень большими файлами

long size = 10L * 1024 * 1024 * 1024; // 10 GB
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, size);

➡️ Даже огромные файлы можно обрабатывать кусками, без полного чтения в память.

🔄 Двусторонний доступ

buffer.put(0, (byte) 'X');
System.out.println((char) buffer.get(0));

➡️ Одно и то же отображение позволяет и читать, и писать данные на месте.

🧱 Ограничения

Memory-mapped файлы зависят от ОС и архитектуры. Если закончилась виртуальная память — программа рухнет.

➡️ Нужно аккуратно выбирать размер отображения и закрывать ресурсы.

🧵 Использование в многопоточке

// Несколько потоков читают один и тот же MappedByteBuffer

➡️ Общая память = быстрый обмен, но придётся синхронизировать доступ.


🗣️ Запомни:Memory-mapped files — это способ работать с файлами так, будто они часть оперативки. Он даёт скорость и гибкость, но требует аккуратного контроля памяти и синхронизации.

🏗 Java Module System (JPMS) — модульность приложения

С Java 9 появилась модульная система (JPMS), которая помогает разделять проект на независимые блоки и жёстко контролировать зависимости. Это шаг дальше от обычных JAR-файлов и классического classpath.

📦 Создание модуля через module-info.java

module com.example.app {
    requires com.example.service;
    exports com.example.app.api;
}

➡️ Файл module-info.java лежит в корне src/com.example.app и описывает, какие модули нужны (requires) и какие пакеты доступны наружу (exports). Всё остальное скрыто.

🔒 Инкапсуляция пакетов

module com.example.service {
    exports com.example.service.api;
    // внутренние классы не экспортируются
}

➡️Код внутри модуля по умолчанию недоступен извне. Это защита от случайного использования «внутренних» API.

🔗 Транзитивные зависимости

module com.example.web {
    requires transitive com.example.service;
}

➡️ Если модуль A требует B как transitive, то любой, кто подключает A, автоматически получает доступ к B.

🧩 Пример: приложение из трёх модулей

com.example.model   → только данные
com.example.service → бизнес-логика
com.example.app     → точка входа

➡️ Модули явно описывают связи. Код не сможет обратиться к тому, что не экспортировано.

⚠️ Ошибка при неправильной зависимости

module com.example.model {
    // ничего не экспортирует
}

module com.example.app {
    requires com.example.model;
}

➡️ Компилятор выдаст ошибку: package ... is not visible. Нужно явно exports.

🚦 Сравнение с классическим classpath

👍 classpath: всё видно всем, легко словить «spaghetti» зависимостей.
👍 modules: строгие границы, меньше сюрпризов при рефакторинге.

🔧 Совместимость и migration

🔴 Старые JAR можно подключать через automatic modules.
🔴 Постепенно можно переносить проект на полноценные модули.

🗣️ Запомни: JPMS — это не только про разбиение проекта, но и про контроль связей. Модули делают систему чище, безопаснее и помогают строить большие приложения без хаоса зависимостей.

☕️Функции в языке Java

В этом видео автор подробно разбирает, как создавать и использовать функции (методы) в Java.
Пошагово объясняется, как объявлять методы, передавать параметры, возвращать значения и вызывать их из других частей программы.

🤩 Java Фишки и трюки || #Видео

⌨️ Что такое default методы интрефейса?

Java 8 позволяет добавлять неабстрактные реализации методов в интерфейс, используя ключевое слово default:

interface Example {
    int process(int a);
    default void show() {
        System.out.println("default show()");
    }
}

✔️Если класс реализует интерфейс, он может, но не обязан, реализовать методы по-умолчанию, уже реализованные в интерфейсе. Класс наследует реализацию по умолчанию.

✔️Если некий класс реализует несколько интерфейсов, которые имеют одинаковый метод по умолчанию, то класс должен реализовать метод с совпадающей сигнатурой самостоятельно. Ситуация аналогична, если один интерфейс имеет метод по умолчанию, а в другом этот же метод является абстрактным - никакой реализации по умолчанию классом не наследуется.

✔️Метод по умолчанию не может переопределить метод класса java.lang.Object.

✔️Помогают реализовывать интерфейсы без страха нарушить работу других классов.

✔️Позволяют избежать создания служебных классов, так как все необходимые методы могут быть представлены в самих интерфейсах.

✔️Дают свободу классам выбрать метод, который нужно переопределить.

✔️Одной из основных причин внедрения методов по умолчанию является возможность коллекций в Java 8 использовать лямбда-выражения.

Вызывать default метод интерфейса в реализующем этот интерфейс классе можно используя ключевое слово super вместе с именем интерфейса:

interface Paper {
    default void show() {
        System.out.println("default show()");
    }
}

class Licence implements Paper {
    public void show() {
        Paper.super.show();
    }
}

⌨️ Приведение типов. Понижение и повышение типа

Java является строго типизированным языком программирования, а это означает, то что каждое выражение и каждая переменная имеет строго определенный тип уже на момент компиляции. Однако определен механизм приведения типов (casting) - способ преобразования значения переменной одного типа в значение другого типа.

В Java существуют несколько разновидностей приведения:

✔️ Тождественное (identity). Преобразование выражения любого типа к точно такому же типу всегда допустимо и происходит автоматически.

✔️ Расширение (повышение, upcasting) примитивного типа (widening primitive). Означает, что осуществляется переход от менее емкого типа к более ёмкому. Например, от типа byte (длина 1 байт) к типу int (длина 4 байта). Такие преобразование безопасны в том смысле, что новый тип всегда гарантировано вмещает в себя все данные, которые хранились в старом типе и таким образом не происходит потери данных. Этот тип приведения всегда допустим и происходит автоматически.

✔️ Сужение (понижение, downcasting) примитивного типа (narrowing primitive). Означает, что переход осуществляется от более емкого типа к менее емкому. При таком преобразовании есть риск потерять данные. Например, если число типа int было больше 127, то при приведении его к byte значения битов старше восьмого будут потеряны. В Java такое преобразование должно совершаться явным образом, при этом все старшие биты, не умещающиеся в новом типе, просто отбрасываются - никакого округления или других действий для получения более корректного результата не производится.

✔️ Расширение объектного типа (widening reference). Означает неявное восходящее приведение типов или переход от более конкретного типа к менее конкретному, т.е. переход от потомка к предку. Разрешено всегда и происходит автоматически.

✔️ Сужение объектного типа (narrowing reference). Означает нисходящее приведение, то есть приведение от предка к потомку (подтипу). Возможно только если исходная переменная является подтипом приводимого типа. При несоответствии типов в момент выполнения выбрасывается исключение ClassCastException. Требует явного указания типа.

✔️ Преобразование к строке (to String). Любой тип может быть приведен к строке, т.е. к экземпляру класса String.

✔️ Запрещенные преобразования (forbidden). Не все приведения между произвольными типами допустимы. Например, к запрещенным преобразованиям относятся приведения от любого ссылочного типа к примитивному и наоборот (кроме преобразования к строке). Кроме того, невозможно привести друг к другу классы, находящиеся на разных ветвях дерева наследования и т.п.

При приведении ссылочных типов с самим объектом ничего не происходит, - меняется лишь тип ссылки, через которую происходит обращение к объекту.

Для проверки возможности приведения нужно воспользоваться оператором instanceof:

Parent parent = new Child();
if (parent instanceof Child) {
    Child child = (Child) parent;
}

#java #casting #upcasting #downcasting

🚀 Project Loom: виртуальные потоки вместо тяжёлых тредов

Java всегда славилась многопоточкой, но классические треды прожорливы: на каждый создаётся отдельный системный поток. Loom это меняет — теперь у нас есть виртуальные потоки (virtual threads).

🧵 Старый способ — тяжёлые треды

Thread thread = new Thread(() -> {
    System.out.println("Hello from thread!");
});
thread.start();

➡️ Потоки живут в ОС. Их немного, и каждый ест память и ресурсы.

⚡️ Новый способ — виртуальные потоки

Thread vThread = Thread.ofVirtual().start(() -> {
    System.out.println("Hello from virtual thread!");
});

➡️ Здесь поток лёгкий. Java сама маппит тысячи виртуальных потоков на несколько системных.

🔄 Масштаб без боли

for (int i = 0; i < 1_000_000; i++) {
    Thread.ofVirtual().start(() -> work());
}

➡️ Миллион потоков без OutOfMemoryError. На обычных тредах — краш.

⏸️ Блокировка без страха

Thread.ofVirtual().start(() -> {
    Thread.sleep(1000); // блокируемся
    System.out.println("Done!");
});

➡️ Виртуальные треды спокойно блокируются. JVM паркует их, освобождая ресурсы.

🌐 Асинхронщина без Future/CompletableFuture

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> fetchFromApi());
    executor.submit(() -> readFromDb());
}

➡️ Каждая задача — в своём виртуальном треде. Асинхронность пишется синхронно.

🔧 Работа с I/O

Files.lines(Path.of("data.txt"))
     .forEach(line -> System.out.println(line));

➡️ Даже блокирующее I/O больше не страшно. В Loom оно «кажется» блокирующим, но реально не тормозит.

📊 Где использовать

🟢 сетевые сервисы (много коннектов);
🟢 микросервисы;
🟢 парсеры/скрейперы;
🟢 всё, где тысячи одновременных задач.

🗣️ Запомни: Про «тредпулы и колбэки» скоро можно будет забыть.

⌨️ Почему 1==1 это true, а 128==128 это false?

Integer a = 128;
Integer b = 128;
System.out.println(a == b); // false

Integer x = 1;
Integer y = 1;
System.out.println(x == y); // true

Это не просто волшебство! Это связано с целочисленным кэшированием в Java.

Для значений в диапазоне от -128 до 127 объекты типа Integer кэшируются, и ссылки на них одинаковы, а для значений за пределами этого диапазона создаются новые объекты, и ссылки на них будут разными. Так как используется оператор ==, то сравниваются ссылки на объекты.

#java #magic

☕️Конструкторы класса

В этом видео автор объясняет, что такое конструкторы в Java и зачем они нужны.
Пошагово показывается, как создавать конструкторы, передавать параметры при инициализации объектов и использовать перегрузку для разных вариантов создания экземпляров класса.

🗣️Запомни: конструкторы упрощают инициализацию объектов и делают код более удобным и читаемым.

🤩 Java Фишки и трюки || #Видео

🚀 Spring Boot 3 + AOT компиляция — реальная производительность

Spring Boot 3 принёс AOT (Ahead-Of-Time) компиляцию. Теперь можно собирать приложение в нативный бинарь через GraalVM и запускать его почти мгновенно. Это не просто оптимизация — это новый уровень для микросервисов.

Разберём, что это даёт в реальных проектах 👇

⚡️ Запуск в миллисекунды

./mvnw -Pnative native:compile
./target/demo

➡️ Обычный Spring Boot на JVM стартует 2–5 секунд. AOT-бинарь поднимается за 30–50 мс. Это критично для serverless и микросервисов, где холодный старт решает.

📦 Минимальные Docker-образы

FROM ghcr.io/graalvm/native-image:latest as builder
WORKDIR /app
COPY . .
RUN ./mvnw -Pnative native:compile

FROM ubuntu:22.04
COPY --from=builder /app/target/demo /demo
CMD ["/demo"]

➡️ В Docker-контейнере не нужна JVM. Итоговый образ весит 30–50 MB вместо 300–400 MB.

🧠 Экономия памяти

JVM-приложение:     150–200 MB RAM  
AOT-приложение:      20–40 MB RAM  

➡️ GraalVM вырезает неиспользуемые классы, рефлексию и динамику. Сервер держит десятки сервисов вместо пары.

🔗 Поддержка Spring Boot Native

@SpringBootApplication
public class DemoApp {
    public static void main(String[] args) {
        SpringApplication.run(DemoApp.class, args);
    }
}

➡️ Код не меняется. Но при сборке Spring генерирует hint'ы (reflect-config.json), чтобы GraalVM понял, какие классы реально нужны.


🧩 Работа с рефлексией и прокси

@TypeHint(types = {MyEntity.class}, access = AccessBits.ALL)
public class MyHints implements NativeConfiguration {}

➡️ В AOT режиме всё статично. Если библиотека лезет через Class.forName(), нужно явно подсказать GraalVM. Иначе приложение упадёт.

⚙️ Async, WebFlux, Security — всё работает

@GetMapping("/hello")
public Mono<String> hello() {
    return Mono.just("Привет из AOT!");
}

➡️ Reactive-приложения и Spring Security совместимы. Но стоит проверить на совместимость сторонние библиотеки — они не всегда поддерживают AOT.


📊 JIT vs AOT: производительность под нагрузкой

🟢 JIT (обычная JVM) быстрее на долгих задачах, потому что оптимизирует байткод во время работы.
🟢 AOT быстрее стартует и экономнее в памяти, но чуть медленнее на горячем коде.

➡️ Для микросервисов и API важнее быстрый старт и лёгкость. Для больших вычислений — JVM.

🔁 CI/CD и DevOps

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: ./mvnw -Pnative native:compile
      - uses: actions/upload-artifact@v3
        with:
          name: demo-binary
          path: target/demo

➡️ AOT встраивается в pipeline. Сборка дольше (5–10 минут), но итоговый бинарь быстрый и лёгкий.

🚨 Ограничения AOT

👍 Долгая компиляция (в разы медленнее, чем обычный mvn package).
👍 Динамические фреймворки (Hibernate proxies, некоторые reflection API) требуют ручных hint'ов.
👍 Не всегда легко дебажить — стек-трейсы короче.

➡️ Но в продакшене эти минусы окупаются.

🗣️ Запомни: AOT в Spring Boot 3 — это не замена JVM, а выбор под задачу. Если важен холодный старт, размер образа и память — используй AOT. Если нужен гибкий код с динамикой и быстрые билды — оставляй JVM. Лучшие проекты совмещают оба подхода.

🌊 JEP 458: Stream Gatherers в Java 22

Java 22 добавила Gatherers — расширение Stream API, которое позволяет собирать элементы не только привычными map/filter/reduce, а своими кастомными способами. Теперь поток можно «собирать» прямо в процессе, без костылей.

📦 Простая идея Gatherer

Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.windowFixed(2))
    .forEach(System.out::println);

➡️ Элементы пакуются по 2 штуки.

Вывод:

[1, 2]
[3, 4]
[5]

🔄 Sliding Window — скользящее окно

Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.windowSliding(3))
    .forEach(System.out::println);

➡️ Формируются окна по 3 элемента с шагом в 1.

Вывод:

[1, 2, 3]
[2, 3, 4]
[3, 4, 5]

🗂 Группировка по условию

Stream.of("a", "b", "x", "y", "c", "d")
    .gather(Gatherers.groupUntil(s -> s.equals("x")))
    .forEach(System.out::println);

➡️ Группа закрывается, когда встречается "x".

Вывод:

[a, b, x]
[y, c, d]

⚙️ Свой Gatherer

Gatherer<Integer, ?, Integer> sumPairs =
    Gatherer.of(
        () -> new int[1], // state
        (state, e, down) -> {
            state[0] += e;
            if (state[0] >= 10) {
                down.push(state[0]);
                state[0] = 0;
            }
            return true;
        },
        (state, down) -> {}
    );

Stream.of(3, 4, 5, 6, 7)
    .gather(sumPairs)
    .forEach(System.out::println);

➡️ Числа суммируются, пока не превысят 10, потом сбрасываются.

12
13

📊 Gatherers.fold — промежуточная агрегация

Stream.of(1, 2, 3, 4, 5)
    .gather(Gatherers.fold(0, Integer::sum))
    .forEach(System.out::println);

➡️ Видим все промежуточные суммы.

Вывод:

1
3
6
10
15

⚖️ Gatherers 🆚 Collectors

Collectors работают в конце стрима (collect(...)).
Gatherers же действуют прямо в процессе, шаг за шагом.

➡️ Это позволяет писать stateful-преобразования, которые раньше выглядели громоздко.


🚀 Реальные применения

1. Буферизация при работе с большими потоками.
2. Batch-загрузки в БД.
3. Скользящие средние и метрики.
4. Stateful-пайплайны без ручного кода.

➡️ Всё это теперь можно писать нативно в Stream API.

🔗 Комбинации

Stream.of(1, 2, 3, 4, 5, 6)
    .gather(Gatherers.windowFixed(2))
    .map(list -> list.stream().mapToInt(i -> i).sum())
    .forEach(System.out::println);

➡️ Сначала разбиваем на пары, потом суммируем каждую.

Вывод:

3
7
11

🗣️ Запомни: Gatherers в Java 22 выводят стримы на новый уровень. Они позволяют обрабатывать данные «на лету» и строить stateful-пайплайны, которые раньше были невозможны без костылей.