⌨️ Есть ли какие-либо рекомендации о том, какие поля следует использовать при подсчете hashCode()?

Общий совет: выбирать поля, которые с большой долью вероятности будут различаться. Для этого необходимо использовать уникальные, лучше всего примитивные поля, например, такие как id, uuid. При этом нужно следовать правилу, если поля задействованы при вычислении hashCode(), то они должны быть задействованы и при выполнении equals().

#java #hashCode #equals

⌨️ Поддержка лямбда выражений в своём коде

В Java лямбда-выражения используются с функциональными интерфейсами, которые имеют ровно один абстрактный метод. Например, стандартный функциональный интерфейс Function из пакета java.util.function представляет собой типичный пример.

Для нашего примера используем встроенный функциональный интерфейс IntUnaryOperator. Он выглядит вот так:

@FunctionalInterface
public interface IntUnaryOperator {
    int applyAsInt(int operand);
}

Этот интерфейс представляет функцию, которая принимает один аргумент типа int и возвращает значение типа int.

import java.util.function.IntUnaryOperator;

public class Main {
    public static int applyOperation(int number, IntUnaryOperator operator) {
        return operator.applyAsInt(number);
    }

    public static void main(String[] args) {
        int number = 5;

        // Лямбда-выражение для удвоения значения
        IntUnaryOperator doubleOperation = x -> x * 2;
        System.out.println("Double: " + applyOperation(number, doubleOperation)); // Double: 10

        // Лямбда-выражение для увеличения значения на 10
        IntUnaryOperator addTenOperation = x -> x + 10;
        System.out.println("Add Ten: " + applyOperation(number, addTenOperation)); // Add Ten: 15
    }
}

В нашем примере метод applyOperation принимает два параметра: число и функциональный интерфейс IntUnaryOperator. Лямбда-выражение используется для определения конкретной функции.

#java #lambda #IntUnaryOperator

☕️Использование метода computeIfAbsent() из интерфейса Map.

Этот метод предлагает удобный способ вычисления и вставки значений в Map, если они отсутствуют.

Пример кода с объяснением:

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> wordLengths = new HashMap<>();
        String word = "apple";

        // Использование computeIfAbsent для вычисления и вставки значения в Map
        wordLengths.computeIfAbsent(word, String::length);

        // Вывод длины слова "apple", которая была вычислена и вставлена в Map
        System.out.println("Длина слова apple: " + wordLengths.get(word));
    }
}

🔒В этом примере мы используем метод computeIfAbsent() для wordLengths, чтобы вычислить и вставить длину слова "apple" в Map, если она отсутствует. Если значение уже присутствует, метод возвращает текущее значение.

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

⌨️ Generics и стирание типов

При компиляции все параметры обобщённых типов удаляются («стираются»), и на их место подставляется либо ограничивающий тип (T extends Number → Number), либо Object.
Это нужно для совместимости с «сырыми» классами до появления Generics в Java 5.

Последствия стирания типов:

1️⃣ Нельзя создавать массивы обобщённого типа:

// Ошибка компиляции!
List<String>[] array = new List<String>[10];

2️⃣ Нельзя проверить во время выполнения, является ли объект именно List<String>:

List<String> list = List.of("a", "b");
if (list instanceof List<String>) { … } // компилятор не пропустит

3️⃣ Перегрузка методов с разными параметрами-дженериками конфликтует:

// Ошибка name clash: стираются оба в process(Collection)
void process(Collection<String> c) { … }
void process(Collection<Integer> c) { … }

Стиpaниe типов позволяет Java Generics не увеличивать размер байт-кода и оставаться совместимой с ранними версиями платформы, но налагает ограничения на проверку и создание обобщённых типов во время выполнения.

🧪 Тесты с JUnit 5 — основные аннотации

JUnit 5 — это не просто @Test. Он принёс гибкость, читаемость и мощные возможности для модульного тестирования.

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

1. ✅ @Test — запуск теста

@Test
void shouldReturnTrueWhenInputIsValid() {
    assertTrue(MyService.validate("test"));
}

➡️ Основная аннотация. Методы с ней — это тесты.

2. 🧱 @BeforeEach и @AfterEach — подготовка и очистка

@BeforeEach
void init() {
    db.connect();
}

@AfterEach
void cleanup() {
    db.disconnect();
}

➡️ Выполняются до и после каждого теста. Удобно для настройки окружения.

3. 🏗 @BeforeAll и @AfterAll — один раз на весь класс

@BeforeAll
static void globalSetup() {
    System.out.println("Запускаем все тесты");
}

➡️ Статические методы, которые выполняются один раз перед/после всех тестов.


4. 🎯 @DisplayName — читаемое имя теста

@DisplayName("Должен вернуть true при корректном email")
@Test
void validEmailTest() {
    assertTrue(EmailValidator.isValid("test@example.com"));
}

➡️ Название будет красиво отображаться в отчётах и IDE.

5. 🧪 @Nested — группировка тестов

@Nested
class WhenUserIsAdmin {
    @Test
    void shouldHaveFullAccess() { ... }
}

➡️Логическая структура внутри тест-класса. Удобно для сценариев.

6. ⚙️ @ParameterizedTest + @ValueSource — параметризованные тесты

@ParameterizedTest
@ValueSource(strings = {"admin", "user", "guest"})
void roleShouldNotBeNull(String role) {
    assertNotNull(role);
}

➡️ Запускает один и тот же тест с разными значениями.

7. 🚫 @Disabled — временно отключить тест

@Disabled("Фича ещё не реализована")
@Test
void futureFeatureTest() {
    fail("не должно запускаться");
}

➡️ Полезно, когда фича в разработке, а тест уже написан.

🗣 Запомни:JUnit 5 — это про читаемость, контроль и минимум лишнего кода. Используй аннотации не ради галочки, а чтобы тесты были понятны даже спустя полгода.

🔄 stream().map().filter().collect() — читаемо и мощно

Java Stream API — это как grep | awk | sort в Linux, только в Java-стиле.
Самая частая связка: map → filter → collect. И она может заменить кучу шаблонного кода.

Допустим, у нас есть список:

List<String> names = List.of("Alice", "bob", "CHARLIE", "dave");

👉 Хочешь получить отфильтрованные, приведённые к верхнему регистру имена, которые длиннее 3 символов?

До Stream API:

List<String> result = new ArrayList<>();
for (String name : names) {
    String upper = name.toUpperCase();
    if (upper.length() > 3) {
        result.add(upper);
    }
}

С stream():

List<String> result = names.stream()
    .map(String::toUpperCase)
    .filter(s -> s.length() > 3)
    .collect(Collectors.toList());

➡️ Читаемо, как SQL: "преобразуй → отфильтруй → собери".


✔️ Разберём подробнее:

1. `map()` — преобразование

   .map(String::trim)
   .map(String::toLowerCase)
   

🔄 Применяет функцию ко всем элементам. Тип может измениться.

2. `filter()` — отбор

   .filter(s -> s.startsWith("a"))
   

❓ Оставляет только те элементы, которые удовлетворяют условию.

3. `collect()` — сборка результата

   .collect(Collectors.toSet())
   .collect(Collectors.joining(", "))
   

🧺 Собирает результат обратно в список, множество, строку и т.д.

📌 Реальный пример — фильтруем активных пользователей по возрасту:

List<User> users = getUsers();

List<String> activeAdults = users.stream()
    .filter(User::isActive)
    .filter(u -> u.getAge() >= 18)
    .map(User::getName)
    .collect(Collectors.toList());

➡️ Без лишних if, for и add() — код фокусируется на логике, а не на реализации.

🗣 Запомни: Цепочка map().filter().collect() — это про читаемый и декларативный код.
Не пиши как императивный робот, пиши как человек: что ты хочешь получить — а не как это сделать.

☕️ final в Java — стоп-сигнал для изменений

В Java final — это как «не трогай»: запрет на изменение.
Но что именно он запрещает? Всё зависит от того, где его поставить: переменная, метод, класс.

Разберёмся 👇

1. 📦 final переменные — нельзя переназначить

final int port = 8080;
port = 9090; // ❌ ошибка компиляции

➡️ Значение фиксируется один раз. Для примитивов — это само значение, для объектов — это ссылка.

final List<String> list = new ArrayList<>();
list.add("Hello");         // ✅ можно
list = new ArrayList<>();  // ❌ нельзя

🧠 Важно: final не делает объект неизменяемым. Только ссылку.

2. 🔒 final методы — нельзя переопределить в наследниках

class Animal {
    final void sleep() {
        System.out.println("Zzz...");
    }
}

class Dog extends Animal {
    // ❌ Нельзя переопределить sleep()
}

➡️ Полезно, если хочешь защитить логику метода от изменений в подклассах.

3. 🧱 final классы — нельзя наследовать вообще

final class Utility {
    static void log(String msg) { ... }
}

class MyUtil extends Utility {} // ❌ ошибка

➡️ Применяют для:

🟢 утилитарных классов (Math, String)
🟢 защиты от подмены логики (SecurityManager, System)

🎯 Частые применения в дикой природе:

🟢 final аргументы в методах → защищает от случайного переназначения
🟢 final поля + @Immutable → хорошая практика для DTO
🟢final классы → в record, enum, String, LocalDate и т.д.


🗣 Запомни:final = контроль. Это способ сказать «вот это трогать нельзя». Используй его осознанно — чтобы сделать поведение предсказуемым и безопасным.

☕️Text Blocks в Java: читаемые строки без \n и слёз

До Java 13 работа с многострочными строками была болью. JSON? HTML? SQL? Только через "\n" + и кучу экранирования.
Но с Text Blocks всё стало проще, понятнее и читаемо.

Сравни:

❌ До:

String html = "<html>\n" +
              "  <body>Hello</body>\n" +
              "</html>";

✅ После (Text Block):

String html = """
    <html>
      <body>Hello</body>
    </html>
    """;

➡️ Стало чище, короче и как в оригинале. Это обычная String, просто оформленная красиво.

✔️ Преимущества Text Blocks:

1. 👍 Читаемость на уровне "как есть"
Код больше не превращается в кашу. Особенно полезно для:

SQL-запросов:

     String query = """
         SELECT id, name
         FROM users
         WHERE active = true
         ORDER BY created_at DESC
         """;
     

HTML/JSON шаблонов:

     String json = """
         {
           "name": "Alice",
           "role": "admin"
         }
         """;
     

2. 👍 Меньше экранирования
Забудь про \", \\n, \\t — теперь можно писать почти как в блокноте.

3. 👍 Автоматическое выравнивание
Java сама уберёт начальные отступы на основе самой "узкой" строки.

Пример:

   String msg = """
           Line 1
           Line 2
       Line 3
       """;
   

➡️ Результат будет:

Line 1
Line 2
Line 3

4. 👍 Интеграция с .formatted()
Нельзя вставить переменные прямо в Text Block?
Используем .formatted() — коротко и читабельно:

String user = "Bob";
String template = """
    {
      "user": "%s",
      "access": "granted"
    }
    """.formatted(user);
````
   ```java
   String s = """
       Hello""";
   System.out.println(s.length());  // 6, а не 5 (есть \n)
   

3. 🟢 Нет интерполяции переменных
Нельзя писать так:

   String name = "Eve";
   String wrong = """
       Hello, $name!
       """;  // ❌ не сработает
   

Вместо этого:

   String right = """
       Hello, %s!
       """.formatted(name);
   

🗣️ Запомни: Text Blocks делают строки в Java человечными. Это не просто сахар — это инструмент, чтобы твой код говорил с тобой на одном языке. Используй их для всего, что требует форматирования — и забудь про + "\n".

🏭 Factory в Java: просто, без бойлерплейта

Factory-паттерн — это способ создавать объекты, не раскрывая логику создания. Но в Java он часто обрастает шаблонами, абстракциями и XML'ем. Зачем? Можно проще.

Допустим, у нас есть интерфейс:

interface Notification {
    void send(String message);
}

И реализации:

class EmailNotification implements Notification {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

class SmsNotification implements Notification {
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

➡️ А теперь сама Factory — без лишнего:

class NotificationFactory {
    public static Notification create(String type) {
        return switch (type) {
            case "email" -> new EmailNotification();
            case "sms"   -> new SmsNotification();
            default      -> throw new IllegalArgumentException("Unknown type");
        };
    }
}

Использование:

Notification n = NotificationFactory.create("email");
n.send("Hello world!");

✔️ Что получили:

1. 👍 Централизованное создание объектов
Меняем реализацию в одном месте.

2. 👍 Гибкость без наследования
Можно возвращать любые классы — хоть анонимные, хоть лямбды.

3. 👍 Без бойлерплейта
Никаких XML, DI-фреймворков и пяти уровней абстракции.


⚠️ Но не переусердствуй:

1. 🟢 Не делай фабрику ради фабрики
Если new работает — не трогай.

2. 🟢 Не забывай про enum
Часто enum c фабрикой — читается лучше, чем строки.

🗣️ Запомни: Factory — это не про паттерны ради паттернов. Это про чистый код и простую подмену реализаций. Не усложняй — Java и так может быть элегантной.

🚀 Кеширование с @Cacheable — быстро и просто в Spring

Когда метод тяжёлый (долго считает, лезет в БД или API) — зачем вызывать его 100 раз, если результат тот же?
Решение: кеш. В Spring это делается одной аннотацией.

✅ Что делает @Cacheable?

Она сохраняет результат метода в кеш.
При повторном вызове с теми же аргументами — возвращает значение из кеша, не запуская метод снова.

@Cacheable("users")
public User getUserById(Long id) {
    System.out.println("Fetching from DB...");
    return userRepository.findById(id).orElseThrow();
}

Первый вызов: метод выполнится → результат кешируется.
Следующие вызовы с тем же id: результат берётся из кеша.

⚙️ Как включить кеш?

1. Добавь зависимость (если ещё нет):

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

2. Включи кеш в @Configuration:

@EnableCaching
@SpringBootApplication
public class MyApp { }

Spring по умолчанию использует простой in-memory кеш (ConcurrentHashMap), но можно подключить Caffeine, Redis, Ehcache и т.д.

🔍 Продвинутые фишки:

🎯 Ключ кеша по полям:

@Cacheable(value = "products", key = "#category + ':' + #limit")
public List<Product> getTopProducts(String category, int limit) { ... }

⛔️ Пропуск кеша при null:

@Cacheable(value = "data", unless = "#result == null")
public Data fetchData(String key) { ... }

🔁 Обновление кеша вручную:

@CachePut("users")
public User updateUser(User user) { ... }

🧹 Очистка кеша:

@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) { ... }

🗣 Запомни:@Cacheable — это «копим и не дёргаем зря».
С ним ты ускоряешь работу приложения без лишнего кода, особенно если есть дорогие вызовы (БД, сеть, парсинг).

☕️ Java - Полный Курс по Java

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

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

⌨️ Что такое класс Object? Какие в нем есть методы?

Object это базовый класс для всех остальных объектов в Java. Любой класс наследуется от Object и, соответственно, наследуют его методы:

public boolean equals(Object obj) – служит для сравнения объектов по значению;

int hashCode() – возвращает hash код для объекта;

String toString() – возвращает строковое представление объекта;

Class getClass() – возвращает класс объекта во время выполнения;

protected Object clone() – создает и возвращает копию объекта;

void notify() – возобновляет поток, ожидающий монитор;

void notifyAll() – возобновляет все потоки, ожидающие монитор;

void wait() – остановка вызвавшего метод потока до момента пока другой поток не вызовет метод notify() или notifyAll() для этого объекта;

void wait(long timeout) – остановка вызвавшего метод потока на определённое время или пока другой поток не вызовет метод notify() или notifyAll() для этого объекта;

void wait(long timeout, int nanos) – остановка вызвавшего метод потока на определённое время или пока другой поток не вызовет метод notify() или notifyAll() для этого объекта;

protected void finalize() – может вызываться сборщиком мусора в момент удаления объекта при сборке мусора.

#java #Object #methods

📈 Покрытие кода с JaCoCo — видишь всё, что тесты реально проверяют

Нужен простой способ понять, какие строки кода вообще исполняются при тестировании?
JaCoCo делает это красиво: запускаешь тесты — получаешь отчёт в HTML с краской по строкам.


🔧 Пример настройки под Maven:

В pom.xml добавляешь:

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.10</version>
  <executions>
    <execution>
      <goals>
        <goal>prepare-agent</goal>
      </goals>
    </execution>
    <execution>
      <id>report</id>
      <phase>verify</phase>
      <goals>
        <goal>report</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Теперь просто запускаешь:

mvn clean verify

После этого открой отчёт:

open target/site/jacoco/index.html

🎨 Там ты увидишь список классов, методов, строки — зелёные (исполнялись), красные (нет).

👀 Пример из жизни:

Есть метод:

public int divide(int a, int b) {
    if (b == 0) throw new IllegalArgumentException("zero");
    return a / b;
}

Если тесты вызывают только divide(10, 2) — то строка с исключением будет красной (не покрыта).
Значит, ты пропустил случай деления на 0 — тест не полный.

📌 Хоть это и "плагин", на практике — очень мощный инструмент: видишь, где тесты работают, а где просто "для галочки".

Тесты без покрытия — это как замок на двери без ключа. Видимость есть, защиты нет.

🗣️ Запомни: JaCoCo не требует сложной настройки, но даёт мощную обратную связь. Смотришь отчёт — видишь, где твой код «голый». А дальше решаешь: прикрыть или оставить так.

🔄 Observer на чистом Java — реакция без Spring и магии

Нужно, чтобы один объект реагировал на изменения другого? Без тайных фреймворков, просто на Java?

Решение — паттерн Наблюдатель (Observer). Он позволяет подписчикам автоматически узнавать об изменениях.

📦 Минимальный пример:

// Observable (Subject)
class NewsAgency {
    private List<NewsListener> listeners = new ArrayList<>();

    public void addListener(NewsListener l) {
        listeners.add(l);
    }

    public void publish(String news) {
        for (NewsListener l : listeners) {
            l.update(news);
        }
    }
}

// Observer (Listener)
interface NewsListener {
    void update(String news);
}

// Конкретный подписчик
class TelegramBot implements NewsListener {
    public void update(String news) {
        System.out.println("🔔 Telegram получил: " + news);
    }
}

▶️ Использование:

public class Main {
    public static void main(String[] args) {
        NewsAgency agency = new NewsAgency();
        agency.addListener(new TelegramBot());

        agency.publish("Java 21 уже вышел!");
        agency.publish("🧵 Loom теперь в preview!");
    }
}

📤 Вывод:

🔔 Telegram получил: Java 21 уже вышел!
🔔 Telegram получил: 🧵 Loom теперь в preview!

🛠 Можно сделать гибче:

Добавь нескольких подписчиков:

class EmailNotifier implements NewsListener {
    public void update(String news) {
        System.out.println("📧 Email-рассылка: " + news);
    }
}

agency.addListener(new EmailNotifier());

Теперь все слушатели получают событие одновременно.


🗣️ Запомни: Паттерн Observer — отличный способ организовать реактивное поведение без зависимости от GUI, фреймворков или событийных систем. Работает в CLI, бэкенде, десктопе и даже Arduino. Просто и гибко.

☕️ Хватит писать циклы! Java 8 дала тебе больше

С 8-й версии Java предлагает мощные инструменты для работы с коллекциями — и пора ими воспользоваться. Забудь про for и while, когда можно писать элегантно и декларативно.

В статье ты найдёшь:
📌 10 лучших методов из Stream API, которые экономят строки кода
📌 Как заменить громоздкие циклы одной строкой
📌 Примеры filter(), map(), collect() и других трюков
📌 Объяснение, почему функциональный стиль — это не боль, а кайф
📌 Практические сценарии: фильтрация, преобразование, группировка, подсчёты

➡️ Читайте и наслаждайтесь

🗣️ Пиши меньше, делай больше. Stream API — must-have для современного джависта.

🤩 Java Фишки и трюки || #Cтатья

🌐 WebClient — современная замена RestTemplate в Java


RestTemplate давно знаком, но теперь Spring рекомендует использовать WebClient. Это не просто новый способ сделать HTTP-запросы — это полноценный инструмент, который умеет работать асинхронно, поддерживает реактивность и даёт гораздо больше контроля над процессом.

Вот как выглядит простой GET-запрос:

WebClient client = WebClient.create();

String body = client.get()
    .uri("https://api.github.com/users/octocat")
    .retrieve()
    .bodyToMono(String.class)
    .block();

System.out.println(body);

Здесь bodyToMono(String.class) возвращает реактивный тип Mono, который содержит результат. Если вызвать .block(), запрос будет выполняться синхронно, так что можно легко внедрять WebClient даже в привычный код.

Для POST-запроса с телом используем:

WebClient client = WebClient.create("https://httpbin.org");

String response = client.post()
    .uri("/post")
    .header("Content-Type", "application/json")
    .bodyValue("{\"name\":\"PyLinux\"}")
    .retrieve()
    .bodyToMono(String.class)
    .block();

System.out.println(response);

Ошибки обрабатываются через onStatus, например, для 4xx:

client.get()
    .uri("https://api.github.com/404")
    .retrieve()
    .onStatus(status -> status.is4xxClientError(), resp -> {
        System.out.println("Ошибка клиента: " + resp.statusCode());
        return Mono.error(new RuntimeException("Client error"));
    })
    .bodyToMono(String.class)
    .block();

Если нужно передать заголовки или параметры:

WebClient client = WebClient.builder()
    .baseUrl("https://api.example.com")
    .defaultHeader("Authorization", "Bearer your_token")
    .build();

String data = client.get()
    .uri(uriBuilder -> uriBuilder
        .path("/data")
        .queryParam("limit", 10)
        .build())
    .retrieve()
    .bodyToMono(String.class)
    .block();

Таким образом, WebClient позволяет легко делать запросы с любыми параметрами и заголовками, при этом можно управлять асинхронностью и реактивностью без лишних сложностей.


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

☕️ Что такое Project Loom?

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

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

☕️ List.of() в Java — быстро, но не всегда безопасно

С Java 9 появился удобный способ создать список:

List<String> names = List.of("Alice", "Bob", "Charlie");

Выглядит лаконично, работает быстро — но есть нюанс.

⚠️ Подводные камни

1️⃣.📛 Список неизменяемый

List<String> list = List.of("a", "b");
list.add("c");       // 💥 UnsupportedOperationException
list.remove("a");    // 💥 тоже ошибка

Любая попытка изменить список — ошибка во время выполнения. Это не ArrayList, а immutable List.

2️⃣.💣 Нельзя null

List<String> list = List.of("hello", null);  // 💥 NullPointerException

Даже один null — и всё падает. Потому что List.of() не допускает null ни в одном элементе.

3️⃣.🎭 Не всегда List, который ты ожидаешь

System.out.println(List.of("a", "b").getClass());
// class java.util.ImmutableCollections$ListN

Это не ArrayList, не LinkedList. Это внутренний тип, оптимизированный под неизменяемость.

Если твой код ждёт ArrayList и будет кастить — ловишь ClassCastException.

🧪 Где безопасно использовать:

🟢 Константные списки (List.of(DAYS))
🟢 Аргументы в методах, где ничего не модифицируется
🟢 Когда 100% уверен, что null нет

✅ Альтернатива с возможностью изменения:

List<String> modifiable = new ArrayList<>(List.of("a", "b", "c"));
modifiable.add("d");  // 👍 теперь можно

🗣️ Запомни: List.of() — круто для коротких, неизменяемых данных.
Но если планируешь менять список или есть шанс на null — лучше явно используй `ArrayList`.
Не пались на удобстве — знай, что лежит под капотом.

🧵 Используй try-with-resources с потоками правильно (и продвинуто)

Если ты до сих пор закрываешь потоки руками или думаешь, что try-with-resources — это только для файлов, смотри:

🛠 Пример 1: чтение и закрытие автоматически

try (BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

☑️ Поток закрывается автоматически — даже если внутри случится исключение.


🧪 Пример 2: кастомный ресурс (любой AutoCloseable)

public class TempResource implements AutoCloseable {
    public void doSomething() {
        System.out.println("Работаем с ресурсом");
    }

    @Override
    public void close() {
        System.out.println("Ресурс закрыт");
    }
}

try (TempResource res = new TempResource()) {
    res.doSomething();
}

🧠 Всё, что реализует AutoCloseable, можно оборачивать в try-with-resources. Это не только файлы, но и сетевые соединения, стримы, логи, сессии Hibernate и др.

🕸 Пример 3: несколько ресурсов

try (
    InputStream in = new FileInputStream("input.txt");
    OutputStream out = new FileOutputStream("output.txt")
) {
    in.transferTo(out);
}

🔒 Все ресурсы закроются в обратном порядке.


🗣️ Запомни: try-with-resources — не просто синтаксический сахар. Это способ писать надёжный код без утечек ресурсов и без лишнего шаблонного кода. Особенно полезно при работе с сетью, файлами, базами данных и внешними API.

🧠 Java и AI: как использовать LangChain4J в 2025

Считаешь Java не для AI? Серьёзно ошибаешься! LangChain, фреймворк для разработки с языковыми моделями, теперь уже доступен и для Java — через LangChain4J.

В статье ты узнаешь:

📌 Как использовать LangChain4J для создания цепочек запросов с LLM
📌 Взаимодействие с векторными хранилищами и RAG
📌 Примеры кода на Java для NLP-задач
📌 Почему Java‑специалистам уже пора в AI

➡️ Читайте и наслаждайтесь

🗣️ Java всё ближе к языкам будущего. Попробуй новое направление уже сейчас!

🤩 Java Фишки и трюки || #Cтатья