Почему обработка отсортированного массива быстрее, чем неотсортированного? 🚀

Вы когда-нибудь задумывались, почему работа с отсортированными данными быстрее? Разберёмся на примере Java (и программирования в целом). 🧑‍💻



🔮 1. Предсказание ветвлений (Branch Prediction)
Современные процессоры используют технику под названием предсказание ветвлений, чтобы угадать результат условных операторов (например, if). Если предсказание верное, процессор выполняет инструкции быстро. Но если предсказание ошибочное, процессор вынужден откатить выполнение и начать заново, что замедляет работу.

- Отсортированные массивы: В отсортированном массиве данные следуют предсказуемым шаблонам. Например, если вы проверяете условие if (array[i] > threshold), результаты будут более последовательными (например, все true после определённого момента). Это помогает предсказателю ветвлений угадывать правильно, уменьшая простои.

- Неотсортированные массивы: В неотсортированном массиве результаты условных проверок более случайны. Это затрудняет работу предсказателя, увеличивая количество ошибок и замедляя выполнение.



🧠 2. Эффективность кэша
Кэш процессора — это быстрая память, которая хранит недавно использованные данные. Доступ к данным из кэша намного быстрее, чем из основной памяти.

- Отсортированные массивы: При обработке отсортированного массива данные читаются последовательно. Это улучшает эффективность кэша, так как процессор может заранее загружать соседние элементы, уменьшая количество промахов кэша.

- Неотсортированные массивы: В неотсортированном массиве доступ к данным менее предсказуем, что приводит к большему количеству промахов кэша и замедлению работы.



🛠 3. Алгоритмические оптимизации
Некоторые алгоритмы специально разработаны для работы с отсортированными данными. Например:
- Бинарный поиск: Работает только с отсортированными массивами и имеет сложность O(log n), что намного быстрее линейного поиска (**O(n)**) в неотсортированном массиве.
- Слияние массивов: Объединение двух отсортированных массивов происходит эффективнее, чем неотсортированных.



🧪 Пример: Предсказание ветвлений в действии
Рассмотрим пример кода:

int sum = 0;
for (int i = 0; i < array.length; i++) {
    if (array[i] >= 128) {
        sum += array[i];
    }
}

- Если массив отсортирован, условие if будет сначала всегда false, а потом всегда true. Это помогает предсказателю работать эффективно.
- Если массив неотсортирован, условие if будет выполняться хаотично, что приведёт к частым ошибкам предсказания и замедлит программу.


⏱ Бенчмаркинг
Вы можете сами проверить разницу в производительности, запустив тесты на отсортированных и неотсортированных массивах. Отсортированный массив будет обрабатываться быстрее благодаря описанным выше причинам.


🎯 Вывод
Основная причина, по которой обработка отсортированного массива быстрее, — это предсказание ветвлений. Отсортированные данные делают выполнение программы более предсказуемым, уменьшая простои процессора. Также важны эффективность кэша и алгоритмические оптимизации.

👉@BookJava

Совет по Spring Boot💡

Когда вам нужно настроить bean, предоставляемый Spring Boot, проверьте наличие интерфейсов *Customizer - велика вероятность, что вы сможете настроить bean, не отказываясь от автоконфигурации.

👉@BookJava

Совет по Java 💡

Чтобы сделать большие и сложные цепочки компараторов более читаемыми, мне нравится присваивать компараторы переменным, имена которых начинаются с "by". Таким образом, вызов sorted() становится меньше и читается почти как естественный язык. Кроме того, вы можете использовать статический импорт.

👉@BookJava

🖥️ Java: передача по значению или по ссылке? 🤔

В Java передача данных происходит ТОЛЬКО по значению (pass-by-value). Однако работа с объектами может ввести в заблуждение и создать впечатление, что передача идет по ссылке.

🔹 Как работает передача в Java?
✅ Примитивные типы (`int`, `double`, `char`): передается копия значения. Изменения внутри метода не влияют на оригинальную переменную.

✅ Объекты (экземпляры классов): передается копия ссылки на объект, а не сам объект. Внутри метода можно изменить состояние объекта, но нельзя изменить саму ссылку на него.

📌 Примеры
🔹 Передача примитивов (значение не изменяется)

public class Test {
    public static void modifyPrimitive(int num) {
        num = 10;  // Это изменение локальное
    }

    public static void main(String[] args) {
        int x = 5;
        modifyPrimitive(x);
        System.out.println(x);  // Выведет: 5 (не изменилось)
    }
}

🔹 Передача объекта (изменение состояния объекта сохраняется)

class Person {
    String name;
}

public class Test {
    public static void modifyObject(Person p) {
        p.name = "Alice";  // Изменяет состояние объекта
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Bob";
        modifyObject(person);
        System.out.println(person.name);  // Выведет: Alice
    }
}

🔹 Переназначение ссылки (не изменяет оригинальный объект)

class Person {
    String name;
}

public class Test {
    public static void reassignReference(Person p) {
        p = new Person();  // Переназначение ссылки (локально)
        p.name = "Charlie";
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Bob";
        reassignReference(person);
        System.out.println(person.name);  // Выведет: Bob (не изменилось)
    }
}

🔥 Итог
🔹 Java всегда передает данные по значению!
🔹 Примитивы передаются как копии значений.
🔹 Объекты передаются как копии ссылок, но изменения внутри объекта сохраняются.
🔹 Если внутри метода изменить саму ссылку, это не повлияет на оригинальный объект.

👉@BookJava

Совет по Java 💡☕️

Чтобы получить все дни месяца, вы можете начать с объекта YearMonth, получить его первый день, а затем использовать функцию datesUntil(), которая возвращает Stream всех дней до указанной даты.

👉@BookJava

🚀 Совет по Java API 🚀

При использовании Integer.valueOf(int) помните, что значения в диапазоне от -128 до 127 кэшируются для повышения производительности. За пределами этого диапазона создаются новые объекты.

Размер кэша можно контролировать с помощью опции -XX:AutoBoxCacheMax=<размер>. 🔥

👉@BookJava

В чем разница между Checked и Unchecked исключениями во время выполнения?

Да, в Java есть существенные различия между checked (проверяемыми) и unchecked (непроверяемыми) исключениями во время выполнения.

1. Проверка на этапе компиляции
- Checked исключения: Проверяются на этапе компиляции. Компилятор требует, чтобы вы либо обработали исключение (с помощью try-catch), либо объявили его в сигнатуре метода (с помощью throws). Если этого не сделать, код не скомпилируется.
- Unchecked исключения: Не проверяются на этапе компиляции. Компилятор не требует их обработки или объявления. Обычно они возникают из-за логических ошибок в коде (например, NullPointerException, ArrayIndexOutOfBoundsException).

2. Поведение во время выполнения
- Checked исключения: Эти исключения обычно связаны с внешними факторами (например, проблемы с файловым вводом-выводом, сетевыми соединениями) и могут возникать в ходе нормального выполнения программы. Если такое исключение выбрасывается и не обрабатывается, оно будет передаваться вверх по стеку вызовов, пока не будет перехвачено или программа не завершится.
- Unchecked исключения: Эти исключения часто вызваны ошибками в коде (например, деление на ноль, обращение к null). Если такое исключение выбрасывается и не перехватывается, оно также будет передаваться вверх по стеку вызовов, но, поскольку их не требуется объявлять или обрабатывать, это может привести к неожиданному завершению программы.

3. Наследование
- Checked исключения: Все исключения, которые наследуют Exception (но не RuntimeException), являются проверяемыми.
- Unchecked исключения: Все исключения, которые наследуют RuntimeException или Error, являются непроверяемыми.

4. Примеры
- Checked исключения: IOException, SQLException, ClassNotFoundException.
- Unchecked исключения: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

5. Обработка во время выполнения
- Checked исключения: Поскольку они проверяются на этапе компиляции, вы обязаны явно их обрабатывать. Это делает код более устойчивым, но может увеличить его объем.
- Unchecked исключения: Поскольку они не проверяются на этапе компиляции, их сложнее отлаживать и обрабатывать, так как они могут быть неочевидными в коде.

6. Производительность
- Нет значительной разницы в производительности между checked и unchecked исключениями во время выполнения. Стоимость выбрасывания и перехвата исключений одинакова для обоих типов.

Итог
- Checked исключения: Контролируются компилятором, должны быть обработаны или объявлены, обычно используются для recoverable (восстанавливаемых) ситуаций.
- Unchecked исключения: Не контролируются компилятором, часто возникают из-за ошибок в коде и могут привести к аварийному завершению программы, если не обработаны.

Оба типа исключений ведут себя схожим образом во время выполнения, но ключевое различие заключается в том, как они контролируются и обрабатываются на этапе разработки.

👉@BookJava

Подборка Telegram каналов для программистов

Системное администрирование 📌
https://t.me/sysadmin_girl Девочка Сисадмин
https://t.me/srv_admin_linux Админские угодья
https://t.me/linux_srv Типичный Сисадмин

https://t.me/linux_odmin Linux: Системный администратор
https://t.me/devops_star DevOps Star (Звезда Девопса)
https://t.me/i_linux Системный администратор
https://t.me/linuxchmod Linux
https://t.me/sys_adminos Системный Администратор
https://t.me/tipsysdmin Типичный Сисадмин (фото железа, было/стало)
https://t.me/sysadminof Книги для админов, полезные материалы
https://t.me/i_odmin Все для системного администратора
https://t.me/i_odmin_book Библиотека Системного Администратора
https://t.me/i_odmin_chat Чат системных администраторов
https://t.me/i_DevOps DevOps: Пишем о Docker, Kubernetes и др.
https://t.me/sysadminoff Новости Линукс Linux

1C разработка 📌
https://t.me/odin1C_rus Cтатьи, курсы, советы, шаблоны кода 1С

Программирование C++📌
https://t.me/cpp_lib Библиотека C/C++ разработчика
https://t.me/cpp_knigi Книги для программистов C/C++
https://t.me/cpp_geek Учим C/C++ на примерах

Программирование Python 📌
https://t.me/pythonofff Python академия. Учи Python быстро и легко🐍
https://t.me/BookPython Библиотека Python разработчика
https://t.me/python_real Python подборки на русском и английском
https://t.me/python_360 Книги по Python Rus

Java разработка 📌
https://t.me/BookJava Библиотека Java разработчика
https://t.me/java_360 Книги по Java Rus
https://t.me/java_geek Учим Java на примерах

GitHub Сообщество 📌
https://t.me/Githublib Интересное из GitHub

Базы данных (Data Base) 📌
https://t.me/database_info Все про базы данных

Мобильная разработка: iOS, Android 📌
https://t.me/developer_mobila Мобильная разработка
https://t.me/kotlin_lib Подборки полезного материала по Kotlin

Фронтенд разработка 📌
https://t.me/frontend_1 Подборки для frontend разработчиков
https://t.me/frontend_sovet Frontend советы, примеры и практика!
https://t.me/React_lib Подборки по React js и все что с ним связано

Разработка игр 📌
https://t.me/game_devv Все о разработке игр

Библиотеки 📌
https://t.me/book_for_dev Книги для программистов Rus
https://t.me/programmist_of Книги по программированию
https://t.me/proglb Библиотека программиста
https://t.me/bfbook Книги для программистов
https://t.me/books_reserv Книги для программистов

БигДата, машинное обучение 📌
https://t.me/bigdata_1 Data Science, Big Data, Machine Learning, Deep Learning

Программирование 📌
https://t.me/bookflow Лекции, видеоуроки, доклады с IT конференций
https://t.me/coddy_academy Полезные советы по программированию
https://t.me/rust_lib Полезный контент по программированию на Rust
https://t.me/golang_lib Библиотека Go (Golang) разработчика
https://t.me/itmozg Программисты, дизайнеры, новости из мира IT
https://t.me/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻
https://t.me/nodejs_lib Подборки по Node js и все что с ним связано
https://t.me/ruby_lib Библиотека Ruby программиста

QA, тестирование 📌
https://t.me/testlab_qa Библиотека тестировщика

Шутки программистов 📌
https://t.me/itumor Шутки программистов

Защита, взлом, безопасность 📌
https://t.me/thehaking Канал о кибербезопасности
https://t.me/xakep_1 Статьи из "Хакера"

Книги, статьи для дизайнеров 📌
https://t.me/ux_web Статьи, книги для дизайнеров

Английский 📌
https://t.me/UchuEnglish Английский с нуля

Математика 📌
https://t.me/Pomatematike Канал по математике
https://t.me/phis_mat Обучающие видео, книги по Физике и Математике

Excel лайфхак📌
https://t.me/Excel_lifehack

https://t.me/tikon_1 Новости высоких технологий, науки и техники💡
https://t.me/mir_teh Мир технологий (Technology World)

Вакансии 📌
https://t.me/sysadmin_rabota Системный Администратор
https://t.me/progjob Вакансии в IT

🚀Разбираем принцип работы ConcurrentHashMap

Сегодня разберёмся, почему ConcurrentHashMap лучше подходит для многопоточной работы, чем HashMap, и как он работает внутри.

В отличие от HashMap, который не потокобезопасен и может приводить к бесконечным циклам при одновременной модификации, ConcurrentHashMap использует сегментированную блокировку, что позволяет работать с разными частями карты параллельно без полной блокировки всей структуры.

📌 Основные особенности:
- Делит данные на сегменты (до JDK 8 или использует synchronized и CAS операции (начиная с JDK 8).
- Чтение (get()) не требует блокировки.
- Запись (put()) использует минимально возможные блокировки.
- Нет null ключей и значений (в отличие от HashMap).

Пример использования:

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        map.put("Java", 1);
        map.put("Python", 2);
        map.put("C++", 3);

        System.out.println(map.get("Java")); // 1
    }
}

А вы часто используете ConcurrentHashMap? Поделитесь в комментариях! 👇

👉@BookJava

🚀Как правильно использовать Optional в Java

Optional<T> в Java — это мощный инструмент для работы с возможными null значениями, но часто его используют неправильно. Давайте разберём основные ошибки и лучшие практики.

❌ Плохие примеры:

1️⃣ Использование Optional как поля в классе

class User {
    Optional<String> name; // ❌ Плохая практика
}

Лучше просто использовать String, а если нужно, то оборачивать значение в Optional при возврате.

2️⃣ Использование isPresent() вместо ifPresent()

if (optionalValue.isPresent()) {
    process(optionalValue.get()); // ❌ Неоптимально
}

Лучше так:

optionalValue.ifPresent(this::process); // ✅ Правильный подход

📌 Хороший пример использования:

public Optional<User> findUserById(int id) {
    return Optional.ofNullable(userRepository.get(id));
}

💡 Правильное использование Optional помогает избежать NullPointerException и делает код чище.

🔥 А как вы используете Optional? Пишите в комментариях! 🚀

👉@BookJava

🔥 Разбираем CompletableFuture: Асинхронность в Java без боли

Привет, коллеги! Сегодня поговорим о CompletableFuture, который помогает писать асинхронный код в Java без коллбэков и потерь в читабельности.

📌 1. Почему CompletableFuture?
В Java давно есть Future, но он неудобен:
❌ Нельзя комбинировать несколько задач.
❌ Блокирует поток при вызове .get().
❌ Нет удобных методов для обработки результатов.

👉 CompletableFuture решает все эти проблемы, позволяя комбинировать задачи, обрабатывать ошибки и не блокировать потоки.



📌 2. Базовый пример использования

import java.util.concurrent.CompletableFuture;

public class AsyncExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            sleep(2000);
            return "Привет, мир!";
        });

        future.thenAccept(result -> System.out.println("Результат: " + result));

        System.out.println("Этот текст выведется раньше результата!");
        sleep(3000); // Чтобы программа не завершилась раньше времени
    }

    private static void sleep(int ms) {
        try { Thread.sleep(ms); } catch (InterruptedException ignored) {}
    }
}

🔹 Здесь supplyAsync() выполняет задачу в другом потоке, а thenAccept() позволяет асинхронно обработать результат.



📌 3. Комбинирование нескольких задач

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

CompletableFuture<String> result = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);

System.out.println(result.join()); // Hello World

✅ thenCombine() объединяет результаты двух асинхронных задач.



📌 4. Обработка ошибок (exceptionally)

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) {
        throw new RuntimeException("Что-то пошло не так!");
    }
    return "Все хорошо!";
}).exceptionally(ex -> "Ошибка: " + ex.getMessage());

System.out.println(future.join());

✅ Если в supplyAsync() произошла ошибка, она обработается в exceptionally(), и программа не упадёт.



📌 5. Запуск нескольких задач параллельно

CompletableFuture<Void> allTasks = CompletableFuture.allOf(
    CompletableFuture.runAsync(() -> sleepAndPrint("Задача 1", 1000)),
    CompletableFuture.runAsync(() -> sleepAndPrint("Задача 2", 2000)),
    CompletableFuture.runAsync(() -> sleepAndPrint("Задача 3", 1500))
);

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

private static void sleepAndPrint(String msg, int ms) {
    try { Thread.sleep(ms); } catch (InterruptedException ignored) {}
    System.out.println(msg);
}

✅ allOf() позволяет запустить несколько задач параллельно и дождаться их завершения.



📌 Итог
🔹 CompletableFuture – это мощный инструмент для работы с асинхронностью в Java.
🔹 Позволяет избежать блокировок, обрабатывать ошибки, комбинировать задачи.
🔹 Улучшает читаемость кода по сравнению с Future и ExecutorService.

📢 А как вы используете CompletableFuture в своих проектах? Делитесь в комментариях! 🚀

👉@BookJava

1️⃣ Чем record лучше class в Java?

В Java 14 появился record – новый тип классов, предназначенный для удобного хранения данных. Чем он лучше обычного class? Давайте разберёмся!

🔹 Запись против класса
Обычный класс:

class Person {
    private final String name;
    private final int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

Много бойлерплейта…

Теперь то же самое с record:

record Person(String name, int age) {}

✅ Меньше кода
✅ Автоматически генерируются toString(), equals(), hashCode()
✅ Иммутабельность по умолчанию

⚠️ Когда НЕ стоит использовать record?
- Если нужен изменяемый объект
- Если требуется сложная бизнес-логика внутри класса

Вы уже используете record в своих проектах? Делитесь опытом! 🚀

👉@BookJava

2️⃣ Что нового в Java 21? ТОП-5 фич, которые стоит знать

Java 21 – это LTS-релиз, который принесёт важные улучшения. Вот самые интересные новинки:

1️⃣ Виртуальные потоки (Virtual Threads) 🧵
- Теперь Thread больше не проблема!
- Создание тысячи потоков стало дешёвым и быстрым:

   try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
       executor.submit(() -> System.out.println("Hello, Virtual Thread!"));
   }
   

2️⃣ Pattern Matching для switch
- Больше не нужно кастовать вручную!

   static void test(Object obj) {
       switch (obj) {
           case String s -> System.out.println("Это строка: " + s);
           case Integer i when i > 0 -> System.out.println("Положительное число: " + i);
           default -> System.out.println("Что-то другое");
       }
   }
   

3️⃣ Scoped Values (Альтернатива ThreadLocal)
- Теперь передача данных в потоки стала безопаснее!

   static final ScopedValue<String> USER = ScopedValue.newInstance();
   ScopedValue.runWhere(USER, "Admin", () -> System.out.println(USER.get()));
   

4️⃣ Record Patterns
- Улучшенный record, теперь можно удобно распаковывать данные:

   record Point(int x, int y) {}
   static void printPoint(Object obj) {
       if (obj instanceof Point(int x, int y)) {
           System.out.println("Координаты: " + x + ", " + y);
       }
   }
   

5️⃣ String Templates (в превью!)
- Упрощённое создание строк:

   String name = "Alice";
   String message = STR."Привет, \{name}!";
   

Java 21 делает язык ещё удобнее! Какая фича понравилась больше всего? 🤔

👉@BookJava

🔥 5 паттернов проектирования, которые должен знать каждый Java-разработчик

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


1️⃣ Singleton
Ограничивает создание объекта одним экземпляром. Полезен для логирования, работы с базами данных, кэшей.

🔹 Пример кода (Lazy Initialization, thread-safe):

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

⚡ Используется в Spring Bean, Hibernate SessionFactory.



2️⃣ Factory Method
Позволяет создавать объекты без привязки к конкретному классу. Отлично подходит, если у вас много типов объектов с общей логикой.

🔹 Пример:

interface Product {
    void create();
}

class ConcreteProductA implements Product {
    public void create() { System.out.println("Создан продукт A"); }
}

class ProductFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) return new ConcreteProductA();
        throw new IllegalArgumentException("Неизвестный тип продукта");
    }
}

⚡ Используется в JDBC (DriverManager.getConnection).



3️⃣ Builder
Позволяет создавать сложные объекты пошагово. Альтернатива длинным конструкторам с кучей параметров.

🔹 Пример (Lombok @Builder делает его проще!):

@Builder
public class Car {
    private String model;
    private int year;
    private String engine;
}

Car car = Car.builder().model("Tesla").year(2024).engine("Electric").build();

⚡ Используется в StringBuilder, HttpRequest в Java 11+.



4️⃣ Observer
Позволяет подписаться на события и реагировать на них. Часто используется в GUI, event-driven системах.

🔹 Пример (наблюдатель за событиями):

interface Observer {
    void update(String message);
}

class User implements Observer {
    private String name;
    public User(String name) { this.name = name; }
    public void update(String message) {
        System.out.println(name + " получил уведомление: " + message);
    }
}

class Channel {
    private List<Observer> observers = new ArrayList<>();
    public void subscribe(Observer o) { observers.add(o); }
    public void notifyAll(String message) {
        for (Observer o : observers) { o.update(message); }
    }
}

⚡ Используется в Spring Events, RxJava.



5️⃣ Decorator
Добавляет функциональность объекту без изменения его структуры. Часто применяется в логгировании, кешировании, потоках IO.

🔹 Пример (логирование обертки над OutputStream):

class LoggingOutputStream extends OutputStream {
    private OutputStream wrapped;
    public LoggingOutputStream(OutputStream wrapped) { this.wrapped = wrapped; }
    @Override
    public void write(int b) throws IOException {
        System.out.println("Записываем байт: " + b);
        wrapped.write(b);
    }
}

⚡ Используется в BufferedReader, Logger, Spring Security Filters.



💬 Ну и в заключение
Если вы хотите писать гибкий и масштабируемый код, обязательно используйте паттерны проектирования. А какие из них вы используете в своих проектах чаще всего? Делитесь в комментариях! 🚀

👉@BookJava

🚀 Stream API в Java: 5 мощных трюков, которые ты мог не знать

Stream API – одна из самых крутых фич в Java, но многие используют только map(), filter() и collect(). Давай разберем 5 полезных трюков, которые сделают код элегантнее и эффективнее!

🔹 1. Группировка элементов (Collectors.groupingBy)
Разбиваем список строк на группы по длине:

List<String> words = List.of("apple", "banana", "cat", "dog", "elephant");
Map<Integer, List<String>> grouped = words.stream()
        .collect(Collectors.groupingBy(String::length));

System.out.println(grouped);
// {3=[cat, dog], 5=[apple], 6=[banana], 8=[elephant]}

🔹 2. Уникальные элементы (distinct())
Фильтруем дубликаты в потоке:

List<Integer> numbers = List.of(1, 2, 2, 3, 4, 4, 5);
List<Integer> unique = numbers.stream()
        .distinct()
        .collect(Collectors.toList());

System.out.println(unique); // [1, 2, 3, 4, 5]

🔹 3. Пропуск N элементов (skip(n))
Хотим пропустить первые 3 элемента и взять только оставшиеся:

List<String> names = List.of("Alice", "Bob", "Charlie", "David", "Eve");
List<String> skipped = names.stream()
        .skip(3)
        .collect(Collectors.toList());

System.out.println(skipped); // [David, Eve]

🔹 4. Найти максимальное значение (max())
Допустим, у нас есть список чисел, найдем максимальное:

List<Integer> nums = List.of(10, 20, 30, 5, 15);
Optional<Integer> maxNum = nums.stream().max(Integer::compareTo);

maxNum.ifPresent(System.out::println); // 30

🔹 5. Проверить, содержит ли список нужное значение (anyMatch())
Допустим, нам нужно проверить, есть ли в списке число больше 100:

List<Integer> nums = List.of(10, 50, 200, 30);
boolean hasLargeNumber = nums.stream().anyMatch(n -> n > 100);

System.out.println(hasLargeNumber); // true

🔥 Stream API – это мощный инструмент для работы с коллекциями. Используйте его, и ваш код станет чище, короче и быстрее!

А какие крутые трюки со стримами знаете вы? Делитесь в комментариях! 👇

👉@BookJava