📝 Советы по оптимизации Java кода: избавляемся от лишнего

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

🚀 1. Избегайте ненужного создания объектов
Частая ошибка — создавать объекты там, где можно использовать уже существующие.

❌ Плохо:

String str = new String("Hello"); // Избыточно

✅ Хорошо:

String str = "Hello"; // Используем строковый пул

То же самое касается Integer.valueOf() вместо new Integer().

🔄 2. Используйте StringBuilder вместо конкатенации в цикле
Если вы объединяете строки в цикле, StringBuilder будет значительно быстрее.

❌ Плохо:

String result = "";
for (int i = 0; i < 100; i++) {
    result += i; // Создает новый объект String на каждой итерации
}

✅ Хорошо:

StringBuilder result = new StringBuilder();
for (int i = 0; i < 100; i++) {
    result.append(i);
}

Такой код работает в разы быстрее!

🏎 3. Правильно выбирайте коллекции
Используйте ArrayList, если не нужна частая вставка/удаление элементов в середине списка.
Используйте HashSet, если важны уникальные значения и не нужен порядок.
Используйте LinkedList, если нужна частая вставка/удаление в середине списка.

⚡ 4. Не злоупотребляйте Stream API
Да, Stream API удобен, но иногда он замедляет код. Например:

❌ Плохо:

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(0, Integer::sum);

✅ Хорошо:

int sum = 0;
for (int num : numbers) {
    sum += num;
}

Цикл быстрее, потому что не тратит время на создание объектов и лямбды.

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

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

👉@BookJava

Бесплатный вебинар, который поможет начать изучение Spark с нуля!

👨‍💻🛠👨🏻‍💻 Кому будет полезно?
- Data-инженерам и аналитикам, работающим с большими объемами данных
- Программистам, переходящим с других технологий обработки данных на Spark

Не пропустите прямой эфир, где мы начнем изучение Big Data фреймворка и подробно разберем обработку графов с помощью Spark:
- ключевые понятия, включая структуру графов, а также алгоритмы, доступные в библиотеках GraphX и GraphFrames
- создание и обработку графов на основе различных типов данных
- эффективную работу с большими графами
- 2 популярных алгоритма для анализа данных: PageRank и Connected Components
- интеграцию графов в проекты
- практические примеры построения графов и их анализ

Все участники вебинара смогут продолжить обучение на курсе «Spark Developer» с выгодной скидкой.

➡️ Регистрация: https://vk.cc/cIVWCl

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576

📝 Разбираем @Transactional в Spring: Где Подводные Камни?

Давайте обсудимм одну из самых популярных аннотаций в Spring — @Transactional. Многие знают, что она используется для управления транзакциями, но не все понимают, как она работает под капотом и какие проблемы могут возникнуть. Давайте разбираться!

🔍 Как работает @Transactional?
Когда вы помечаете метод @Transactional, Spring проксирует этот метод и оборачивает его в транзакцию. Это значит, что до начала метода открывается транзакция, а после — либо коммитится (если нет ошибок), либо откатывается (если есть исключение).

Но тут важно помнить:
🔹 @Transactional работает только на public методах (если используется Spring AOP).
🔹 Вызовы методов внутри одного класса не учитывают @Transactional. Если вызвать метод, аннотированный @Transactional, внутри другого метода того же класса, транзакция не создастся.
🔹 По умолчанию, транзакция откатывается только при RuntimeException. Если бросить checked-исключение, Spring не откатит транзакцию.

⚠️ Распространённые ошибки
❌ Аннотация на private методе
Транзакция просто не будет работать, так как Spring AOP не перехватит вызов.

❌ Вызов @Transactional метода внутри того же класса
Транзакция не создастся, так как вызов происходит без участия Spring Proxy. Решение — выносить такие методы в отдельный бин или использовать TransactionTemplate.

❌ Неправильный rollback
Если в методе выбрасывается checked-исключение, Spring по умолчанию **не откатывает** транзакцию. Чтобы изменить это поведение, нужно явно указать `@Transactional(rollbackFor = Exception.class).

✅ Как избежать проблем?
✔️ Всегда ставьте @Transactional на публичные методы.
✔️ Вызывайте @Transactional-методы только через Spring-управляемые бины.
✔️ Контролируйте rollback через rollbackFor.
✔️ Используйте propagation = REQUIRES_NEW, если хотите создать новую независимую транзакцию.

Кто сталкивался с неожиданным поведением @Transactional? Давайте обсудим в комментариях!

👉 @BookJava

🚀 AutoCloseable HttpClient в Java 21 🚀

HttpClient был обновлён и теперь реализует интерфейс AutoCloseable в Java 21. 🔥

👉 @BookJava

Абстракция в Java – что это и зачем нужна?

Одна из ключевых концепций ООП – абстракция. Мы постоянно используем её в Java, даже не задумываясь. Но давайте разберёмся, зачем она нужна и как правильно применять.

📌 Что такое абстракция?
Абстракция – это процесс выделения существенных характеристик объекта, скрывая при этом детали реализации. Это позволяет нам работать с объектами через их интерфейсы, а не конкретные реализации.

Пример из жизни:
Когда вы едете на машине, вам не нужно знать, как работает двигатель. Достаточно уметь жать на газ, тормозить и поворачивать руль. Вот это и есть абстракция – вам доступен только необходимый интерфейс, а детали скрыты.

🔹 Как реализуется абстракция в Java?
В Java абстракция достигается двумя способами:
1. Абстрактные классы (abstract class)
2. Интерфейсы (interface)

🚀 Абстрактные классы
Абстрактный класс может содержать как реализованные, так и абстрактные (без реализации) методы. Его нельзя создать через new, он служит основой для дочерних классов.

abstract class Vehicle {
    abstract void start(); // абстрактный метод, без реализации

    void stop() { 
        System.out.println("Машина остановилась");
    }
}

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Запуск двигателя...");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        car.start();
        car.stop();
    }
}

💡 Тут start() – это абстрактный метод, его реализация будет в Car. А вот stop() реализован в базовом классе.

🚀 Интерфейсы
Интерфейсы содержат только сигнатуры методов (до Java 8), а с Java 8 можно добавлять default и static методы.

interface Engine {
    void start();
}

class ElectricCar implements Engine {
    @Override
    public void start() {
        System.out.println("Электродвигатель включен!");
    }
}

📌 Разница между интерфейсом и абстрактным классом в том, что интерфейсы описывают, что класс ДОЛЖЕН делать, а абстрактные классы – как он МОЖЕТ это делать.

🎯 Где применять абстракцию?
- Если у вас иерархия классов с общими методами – используйте абстрактный класс.
- Если вам нужно гибкое поведение без наследования – используйте интерфейсы.

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

Как вы чаще применяете абстракцию: через абстрактные классы или интерфейсы? Делитесь опытом в комментариях! 👇

👉@BookJava

🚀 Параметры JVM: Какие ключевые стоит знать?

Сегодня я покажу вам самые важные параметры JVM, которые помогут вам оптимизировать работу вашего Java-приложения. Эти флаги влияют на производительность, управление памятью и отладку.

🔥 Управление памятью:
- -Xms<size> – задает начальный размер кучи.
- -Xmx<size> – задает максимальный размер кучи.
- -XX:NewRatio=<n> – определяет соотношение между молодым и старым поколением.
- -XX:SurvivorRatio=<n> – соотношение между Eden и Survivor.

⚡ Гаражная сборка (GC):
- -XX:+UseG1GC – включает G1 Garbage Collector (по умолчанию в Java 9+).
- -XX:+UseParallelGC – включает Parallel GC.
- -XX:+UseZGC – включает экспериментальный ZGC (минимальная пауза).
- -XX:+UseShenandoahGC – еще один GC с низкими задержками.

🛠️ Диагностика и отладка:
- -XX:+PrintGCDetails – подробный вывод информации о сборке мусора.
- -XX:+HeapDumpOnOutOfMemoryError – дамп памяти при OOM.
- -XX:HeapDumpPath=<path> – указывает путь для дампа памяти.
- -XX:+ExitOnOutOfMemoryError – завершает JVM при OOM.

🏎️ Оптимизация JIT:
- -XX:+TieredCompilation – адаптивная компиляция кода.
- -XX:+UseStringDeduplication – уменьшает использование памяти строками.
- -XX:+AlwaysPreTouch – аллокация памяти заранее (полезно для больших heap'ов).

Попробуйте поэкспериментировать с этими параметрами и посмотрите, как они влияют на производительность вашего приложения!

Какие параметры JVM используете вы? Пишите в комментариях!

👉 @BookJava

💥 Apache Kafka: мощь, которой вы еще не владеете! Курс, который сделает вас профи в потоках данных.💥

Превратите свои проекты в образец стабильности и скорости! Учитесь у экспертов, которые знают Kafka изнутри.

На курсе вы научитесь:
- Разворачивать Kafka и настраивать брокеры.
- Использовать API и разрабатывать программы на Kafka Streams, Spring, Akka, ZIO.
- Интегрировать Kafka с другими системами.
- Настроить мониторинг и безопасность.

💼 Реальная практика, живые лекции и диплом, который ценят ведущие компании.

💪 Готовы прокачаться? Пройдите полное тестирование и присоединяйтесь к группе с максимальной скидкой по промокоду "Kafka_5", а также получите доступ к открытым урокам курса: 👉 https://vk.cc/cIX01X

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576

🧵 Разбираемся с CompletableFuture в Java

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

🔹 Что такое CompletableFuture?
CompletableFuture — это часть java.util.concurrent с Java 8, которая позволяет выполнять асинхронные задачи и удобно комбинировать их. В отличие от обычного Future, CompletableFuture поддерживает цепочки вызовов, композицию задач и обработку ошибок.

🔹 Пример использования
Допустим, у нас есть сервис, который загружает данные по сети. Обычный подход синхронного вызова будет блокировать поток, но с CompletableFuture мы можем избежать этого:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Загружаем данные...");
            sleep(2000);
            return "Данные загружены";
        }).thenApply(data -> {
            System.out.println("Обрабатываем: " + data);
            return data.toUpperCase();
        }).thenAccept(System.out::println)
          .exceptionally(ex -> {
              System.out.println("Ошибка: " + ex.getMessage());
              return null;
          });

        sleep(3000); // Даем время асинхронной операции завершиться
    }

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

🔹 Разбор кода
1️⃣ supplyAsync() — запускает асинхронную задачу в отдельном потоке.
2️⃣ thenApply() — позволяет обработать результат (например, изменить его формат).
3️⃣ thenAccept() — принимает готовый результат и выполняет действие.
4️⃣ exceptionally() — обрабатывает возможные ошибки.

🔹 Зачем это нужно?
✅ Улучшает производительность за счет асинхронного выполнения.
✅ Избегает блокировки основного потока.
✅ Позволяет легко комбинировать операции.

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

👉@BookJava

Дикая Java

«Безопасный язык» говорили они, «четкая спецификация» говорили они, «Java не даст вам выстрелить себе в ногу» и прочее в таком духе. Реальность же оказалась куда веселее официальной документации и мнений экспертов.

«JVM темна и полна ужасов». (ц)

https://habr.com/ru/articles/886080/

👉@BookJava

🚀 Используем Optional правильно в Java

Сегодня разберем Optional – мощный инструмент, который помогает избежать NullPointerException. Но многие используют его неправильно! Давайте посмотрим, как его применять эффективно.

❌ Как делать НЕ надо:

Optional<String> optional = Optional.ofNullable(getValue());
if (optional.isPresent()) {
    System.out.println(optional.get());
}

Почему плохо?
- get() без проверки – потенциальная ловушка.
- Лишний if – можно сделать проще.

✅ Как надо:

Optional.ofNullable(getValue()).ifPresent(System.out::println);

или, если нужно значение по умолчанию:

String value = Optional.ofNullable(getValue()).orElse("Default Value");

Крутые приемы с Optional:
✔ orElseGet – лениво вычисляет значение
✔ orElseThrow – выбрасывает исключение, если Optional пуст
✔ map и flatMap – позволяют трансформировать данные

🔥 Советы:
1️⃣ Не используйте Optional для полей классов – это не сериализуемо.
2️⃣ Не передавайте Optional в аргументах методов – это антипаттерн.
3️⃣ Optional хорош для возвращаемых значений – используйте его вместо null.

Как вы используете Optional в своих проектах? Делитесь в комментариях!

👉@BookJava

Используем Lombok правильно: Разбираемся с @Slf4j

Сегодня я расскажу вам о @Slf4j из библиотеки Lombok и о том, как его правильно использовать, чтобы ваш код стал чище и удобнее.

Что такое @Slf4j?
Это аннотация, которая добавляет в ваш класс статическое поле логгера org.slf4j.Logger. Вместо того чтобы писать:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyService {
    private static final Logger log = LoggerFactory.getLogger(MyService.class);
}

Достаточно одной аннотации:

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyService {
}

Теперь в коде можно просто писать:

log.info("Приложение запущено");
log.error("Произошла ошибка: {}", exception.getMessage());

На что обратить внимание?
1️⃣ @Slf4j использует SLF4J API, поэтому вам все равно потребуется подключить реализацию логирования, например Logback:

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
</dependency>

2️⃣ Если нужен другой логгер, можно использовать альтернативные аннотации:
- @Log — для java.util.logging
- @Log4j — для Apache Log4j
- @Log4j2 — для Log4j2

3️⃣ Не забывайте про уровень логирования!
Используйте debug для отладки, info для полезных сообщений, warn для предупреждений и error для ошибок.

Вывод: @Slf4j — это удобный инструмент, который избавляет от лишнего кода и упрощает работу с логированием. Если вы еще не используете Lombok для логирования, самое время попробовать!

👉@BookJava

⚡️ Кастомный toString() в Java – как сделать правильно?

Сегодня поговорим про метод toString() в Java. Казалось бы, мелочь, но грамотная реализация этого метода значительно упрощает отладку и логирование.

❌ Как делать НЕ стоит
Обычная ошибка – использовать toString() по умолчанию или писать его вручную без четкой структуры:

public class User {
    private String name;
    private int age;

    // Ошибочный вариант
    @Override
    public String toString() {
        return "User[name=" + name + ", age=" + age + "]";
    }
}

Минусы такого подхода:
- Код громоздкий и трудно читаемый
- При добавлении новых полей легко забыть их добавить в toString()
- Нет удобного форматирования

✅ Как делать правильно
Лучший вариант – использовать String.format() или StringJoiner, но ещё лучше – библиотеку Lombok или Objects.toString():

import lombok.ToString;

@ToString
public class User {
    private String name;
    private int age;
}

Или без Lombok, но читабельно:

import java.util.Objects;

public class User {
    private String name;
    private int age;

    @Override
    public String toString() {
        return String.format("User{name='%s', age=%d}", name, age);
    }
}

Плюсы:
- Автоматически форматируется
- Читаемый и поддерживаемый код
- Легко расширять

Используйте toString() осознанно, и ваш код станет лучше! Какой способ используете вы?

👉@BookJava

Утренний рефакторинг с Дженной Ортегой*

На относительно простом примере показываю как можно сделать программу «снова великой». Ключевые стадии рефакторинга, Java, эмулятор и Jenna Ortega в нейросетевом исполнении.

https://habr.com/ru/articles/886890/

👉@BookJava

🔥 Почему Optional в Java – не просто контейнер!

Сегодня разберём важную тему: Optional в Java – это не просто удобный способ избежать null, но и мощный инструмент для работы с потоками данных.

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

1️⃣ Избегаем null-чеков
Раньше код был полон if (obj != null), но теперь:

Optional<String> name = Optional.ofNullable(user.getName());
name.ifPresent(System.out::println);

Это делает код чище и понятнее.

2️⃣ Комбинируем с map() и flatMap()
Если у нас есть объект, внутри которого другой объект, а внутри него – ещё один, Optional поможет избежать вложенных if-else:

Optional<String> city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity);

Всё элегантно и лаконично!

3️⃣ Используем orElse() и orElseGet() правильно
❌ Антипаттерн – всегда выполняет new Object():

User user = optionalUser.orElse(new User());

✅ Лучше так – orElseGet() вызовется только если optionalUser пуст:

User user = optionalUser.orElseGet(User::new);

Это особенно важно, если объект тяжёлый в создании.

4️⃣ orElseThrow() – избавляемся от null вообще
Когда отсутствие значения – это ошибка, не бойтесь выбрасывать исключение:

User user = optionalUser.orElseThrow(() -> new RuntimeException("User not found"));

Это делает код безопаснее!

❌ Когда не стоит использовать Optional?
- В полях сущностей (например, JPA) – это может ухудшить производительность.
- Для коллекций – лучше возвращать пустую коллекцию, а не Optional<List<T>>.

А как ты используешь Optional в своём коде? Делись в комментариях! 👇

👉@BookJava

🏆 5 ЗОЛОТЫХ ПРАВИЛ ЧИСТОГО КОДА В JAVA

1️⃣ Понятные названия
Используйте осмысленные имена для переменных, методов и классов. Название должно отвечать на вопрос "Что делает этот код?" без необходимости заглядывать внутрь.
❌ int a = 5;
✅ int maxRetries = 5;

2️⃣ Короткие методы
Огромные методы с кучей логики сложно читать и поддерживать. Разбивайте их на мелкие, понятные части. Хороший метод делает только одну вещь и делает её хорошо.

3️⃣ Минимум вложенности
Чем больше if-else и циклов внутри друг друга — тем сложнее понимать код. Используйте ранний выход (return, continue, break), чтобы уменьшить вложенность.

4️⃣ Избегайте магических чисел
Никогда не вставляйте числа или строки прямо в код. Заводите константы.
❌ if (status == 3) {...}
✅ if (status == ORDER_COMPLETED) {...}

5️⃣ Отказ от комментариев в пользу читаемого кода
Комментарий не должен объяснять что делает код — это обязанность самого кода! Если без комментариев неясно, что происходит, значит, нужно переписать код.

👉 Какое из этих правил вы чаще всего нарушаете? Или, может, у вас есть своё золотое правило чистого кода? Пишите в комментариях!

👉@BookJava