Новая вакансия! Стажёр, мечтающий построить карьеру в ИТ

📍 Локация: вся Россия и всемирная сеть Интернет
График: свободный
Опыт: необязателен, но желание и любопытство — строго необходимо.

📝 Задачи:
– листать свежие стажировки и откликаться по ссылкам,
– читать истории других стажёров,
– заглядывать на вебинары, хакатоны и карьерные мероприятия,
– задавать вопросы и учиться.

💡 От нас:
– возможность трудоустройства в атомной отрасли,
– шанс поработать под руководством топовых ИТ-экспертов
– сообщество таких же увлечённых молодых специалистов.

Подписывайтесь на ИТ-стажировки Росатома и следите за обновлениями.

Советы по Java 💡

Как инициализировать collections или map в Java? Конечно, вы можете использовать, например, статическую инициализацию фабрики (`List.of(...)` или `Map.of(...)`).
Но вы также можете воспользоваться функцией "инициализации двойной скобкой"

👉@BookJava

В чем суть принципа DI из SOLID, и почему с ним так много проблем?

DI — это Dependency Inversion Principle, последний принцип из SOLID. Его суть:

🧠 Модули верхнего уровня не должны зависеть от модулей нижнего уровня. И те, и другие должны зависеть от абстракций. Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.

🔍 Переводим на практику:

Вместо того чтобы класс сам создавал зависимости (new внутри), он получает их снаружи — через конструктор, сеттер или метод. Это и называется внедрение зависимостей (Dependency Injection).

Пример без DI (нарушение DIP):

class UserService {
    private final UserRepository repo = new UserRepository(); // жесткая связка
}

Пример с DI:

class UserService {
    private final UserRepository repo;
    
    public UserService(UserRepository repo) {
        this.repo = repo;
    }
}

Теперь можно легко подменять реализацию UserRepository, например, на InMemoryUserRepository в тестах — и UserService даже не узнает.


⚠️ Почему с этим столько проблем?

1. Избыточность на старте. Для новичков DIP и DI выглядят как «лишние классы и абстракции ни о чём».
2. Сложность в управлении графом зависимостей. Особенно в больших системах, где всё зависит от всего.
3. Контейнеры DI (Spring, Guice, Dagger) могут всё усложнить — магия, ленивая инициализация, прокси, ошибки в рантайме.
4. Соблазн абстрагироваться ради абстракции. Когда вместо пользы получаем тонну интерфейсов без альтернативных реализаций.


💡 Советы:

- Используй DI, но не злоупотребляй абстракциями без нужды.
- Всегда пиши под интерфейс, если есть потенциально 2+ реализации.
- Контейнеры типа Spring делают DI удобным, но важно понимать, что именно они делают под капотом.

📌 DIP — это не про контейнеры, это про независимость и заменяемость.

👉@BookJava

Совет по Java 💡

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

👉@BookJava

Определение и отличие IP адресов LAN, PPP в Java

Чтобы определить IP-адрес локальной машины с использованием Java, примените следующий код:

import java.net.*;

public class GetIP {
    public static void main(String[] args) throws UnknownHostException {
        System.out.println(InetAddress.getLocalHost().getHostAddress());
    }
}

Работа с несколькими сетевыми интерфейсами

Если ваш компьютер оснащён несколькими сетевыми интерфейсами, иногда бывает необходимо обойти весь список интерфейсов и отфильтровать адреса, не являющиеся обратными петлями и являющиеся локальными для сайта. Это особенно актуально при работе в средах с многочисленными сетями.

import java.net.*;
import java.util.*;

public class GetMultiIPs {
    public static void main(String[] args) throws SocketException {
        Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            NetworkInterface iface = interfaces.nextElement();
            if (iface.isLoopback() || !iface.isUp()) continue;
            
            Enumeration<InetAddress> addresses = iface.getInetAddresses();
            while(addresses.hasMoreElements()) {
                InetAddress addr = addresses.nextElement();
                if (addr instanceof Inet4Address) {
                    System.out.println(iface.getDisplayName() + " – " + addr.getHostAddress());
                }
            }
        }
    }
}

👉@BookJava

🧠 Как ускорить Spring Boot при старте: spring-context-indexer

При старте Spring Boot-приложения много времени уходит на classpath scanning. Даже если вы используете @ComponentScan, Spring всё равно перебирает кучу классов в поиске бин-кандидатов. Это рефлексивно и медленно.

📌 Есть способ это оптимизировать — spring-context-indexer.

🔧 Что делать

1. Добавьте зависимость в pom.xml:

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-indexer</artifactId>
  <version>6.1.3</version> <!-- актуальная для Spring Boot 3 -->
  <optional>true</optional>
</dependency>

2. Всё! Spring Boot на этапе компиляции сгенерирует индекс классов с аннотациями (@Component, @Service, @Repository, и т.п.) в META-INF/spring.components.

3. При старте приложения Spring сначала смотрит в индекс, а не сканирует classpath целиком.

💡 Полезно, если:

- У вас много модулей;
- Вы используете fat JAR;
- Приложение долго стартует и важна скорость.

⚠️ Важно

- Работает только с аннотациями Spring, не с кастомными;
- Не забудьте включить annotation processing в IDE (особенно в IntelliJ: Settings → Build, Execution, Deployment → Compiler → Annotation Processors).

📊 Профит: в крупных проектах — до 30–50% ускорения старта.

👉@BookJava

Функциональное программирование в Java с использованием потоков (Streams) и лямбд (Lambdas)

Потоки обрабатывают фильтрацию, сортировку и агрегацию, а лямбды упрощают определение функций.
В Spring они лежат в основе реактивных API, а в соревновательном программировании — позволяют оптимизировать работу с данными.
Пример ниже демонстрирует REST-эндпоинт на Spring для фильтрации пользователей и алгоритм в стиле соревнований для поиска лучшего игрока.

👉@BookJava

🧠 Быстрый профилинг Java: -XX:+PrintCompilation

Хотите понять, что JIT-компилятор делает с вашим кодом и где реально тратится время?
Есть скрытая, но очень полезная фича JVM — флаг:

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintCompilation -jar app.jar

📌 Что даёт?
JVM начнёт логировать все методы, которые JIT компилирует, и в какой момент.
Вы увидите:

- какие методы вызываются чаще всего (горячие точки);
- какие инлайнятся и оптимизируются;
- где есть неожиданные “узкие места”.

💡 Зачем это нужно?

- Быстро найти кандидатов на оптимизацию;
- Понять, почему приложение медленно стартует (компиляция тяжёлых методов);
- Увидеть, какие части кода JIT не трогает (и, возможно, почему).

⚠️ Нюанс: это диагностический инструмент. На продакшене лучше использовать аккуратно (или дублировать трафик на стенд).

👉 Хочешь глубже? Смотри ещё -XX:+PrintInlining — покажет какие методы JVM решила инлайнить (и почему отказалась).

Быстрый взгляд на JIT — и вы понимаете поведение кода куда глубже.

👉@BookJava

Совет 💡

Добавьте в JDBC URL свойство ApplicationName (зависит от БД, не в каждой БД оно есть!). Таким образом, в списке сессий вместо имени JDBC-драйвера будет отображаться имя набора. Это поможет при поиске неисправностей, когда несколько приложений подключаются к одной и той же БД.

👉@BookJava

Как обрабатывать исключения в Java?

Исключения в Java можно аккуратно обрабатывать с помощью блоков try-catch. В блоке try пишется код, который может выбросить исключение, а в блоке catch — что нужно сделать, если это исключение произошло.

Блок finally можно использовать для операций очистки, если в try-catch задействованы внешние ресурсы, такие как файловые менеджеры, соединения с базой данных и т.д.

Вот пример кода, демонстрирующий обработку исключений в Java:

import java.io.FileReader;
import java.io.IOException;
public class ExceptionHandlingExample {
   public static void main(String[] args) {
       FileReader reader = null;
       try {
           reader = new FileReader("nonexistent.txt");
           // Code that might throw an exception
           int character = reader.read();
           System.out.println((char) character);
       } catch (IOException e) {
           // Handling the specific exception
           System.out.println("An error occurred while reading the file: " + e.getMessage());
       } finally {
           // Cleanup code that always executes
           if (reader != null) {
               try {
                   reader.close();
               } catch (IOException e) {
                   System.out.println("Error closing file: " + e.getMessage());
               }
           }
       }
   }
}

👉@BookJava

Какова цель ключевого слова static в Java?

Ключевое слово static в Java используется для объявления членов (переменных, методов, вложенных классов), которые принадлежат самому классу, а не его экземплярам.

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

Например, в следующем классе BankAccount переменные totalAccounts и INTEREST_RATE являются статическими, поэтому они будут доступны только внутри самого класса.

public class BankAccount {
   private String accountHolder;
   private double balance;
   private static int totalAccounts = 0;
   private static final double INTEREST_RATE = 0.05;
  
  
   // The rest of the code here ...
}

👉@BookJava

В чём разница между == и .equals() при сравнении строк?

== сравнивает ссылки на объекты (адреса в памяти), а .equals() сравнивает содержимое строк. Для сравнения строк всегда используйте .equals().

Вот пример, иллюстрирующий разницу:

String str1 = "Hello";
String str2 = "Hello";
String str3 = new String("Hello");
System.out.println(str1 == str2);       // true (один и тот же объект)
System.out.println(str1 == str3);       // false (разные объекты)
System.out.println(str1.equals(str2));  // true (одинаковое содержимое)
System.out.println(str1.equals(str3));  // true (одинаковое содержимое)

👉@BookJava

💡10 незаменимых советов и приёмов Java, которые должен знать каждый разработчик


1. Используйте улучшенный цикл for
Улучшенный цикл for, появившийся в Java 5, позволяет лаконично и эффективно проходить по массивам и коллекциям. Вместо традиционного цикла с индексами можно итерироваться напрямую по элементам, что повышает читаемость кода и снижает вероятность ошибок выхода за пределы массива.

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
 System.out.println(number);
}

2. Используйте дженерики (Generics)
Дженерики позволяют создавать переиспользуемый код, работающий с разными типами данных. Они обеспечивают безопасность типов и избавляют от необходимости явного приведения типов. Результат — более надёжный и удобный для поддержки код.

List<String> names = new ArrayList<>();
names.add("John");
names.add("Jane");
String firstName = names.get(0);

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

StringBuilder message = new StringBuilder("Hello");
message.append(" World");
message.insert(5, " Java");
String result = message.toString();

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

5. Используйте неизменяемые классы (Immutable)
Неизменяемые классы потокобезопасны и дают преимущества в кэшировании, работе с многопоточностью и повышении безопасности. Создавая неизменяемые классы, вы исключаете риск случайных изменений и обеспечиваете целостность данных.

6. Применяйте try-with-resources
При работе с ресурсами, которые нужно закрывать (например, файлы или подключения к базе данных), конструкция try-with-resources гарантирует автоматическое закрытие ресурсов, даже если произойдут исключения. Это упрощает управление ресурсами и снижает риск утечек.

try (FileReader fileReader = new FileReader("data.txt");
 BufferedReader bufferedReader = new BufferedReader(fileReader)) {
 String line = bufferedReader.readLine();
 // Process the data
} catch (IOException e) {
 // Handle the exception
}

7. Используйте перечисления (enum) для констант
Если у вас есть набор связанных констант, лучше использовать enum, а не простые переменные или целочисленные константы. Перечисления обеспечивают безопасность типов, улучшают читаемость кода и легко расширяются.

enum Days {
 MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Days today = Days.MONDAY;

8. Оптимизируйте циклы с помощью break и continue
Оператор break позволяет выйти из цикла досрочно, а continue — пропустить текущую итерацию и перейти к следующей. Грамотное использование этих операторов делает код более эффективным и читаемым.

for (int i = 1; i <= 10; i++) {
 if (i == 5) {
 break; // Exit the loop when i equals 5
 }
 if (i % 2 == 0) {
 continue; // Skip even numbers
 }
 System.out.println(i);
}

9. Используйте библиотеки и фреймворки
В экосистеме Java есть огромное количество библиотек и фреймворков, которые упрощают разработку. Применяйте популярные решения вроде Apache Commons, Gson или Jackson для задач работы с файлами, JSON или базами данных. Это экономит время и избавляет от необходимости «изобретать велосипед».

10. Практикуйте грамотную обработку ошибок
Обработка ошибок — ключ к созданию надёжного и поддерживаемого кода. Используйте механизмы исключений для корректного перехвата и обработки ошибок. Логируйте важные сообщения и давайте пользователям понятную обратную связь при возникновении ошибок. Это облегчает отладку и улучшает пользовательский опыт.

👉@BookJava

⁉️ Хотите научиться строить масштабируемые и отказоустойчивые решения на Kafka?

На открытом уроке «Архитектурные паттерны работы с Kafka: от простого к масштабируемому» 13 августа в 18:00 МСК мы разберем основные паттерны и архитектурные подходы для работы с Kafka в микросервисах. Вы освоите Event Sourcing и CQRS и узнаете, как правильно обрабатывать ошибки и гарантировать доставку сообщений.

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

➡️ Присоединяйтесь и получите скидку на большой курс «Apache Kafka»: https://vk.cc/cOir4i

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

💡Совет по Java №1: Прощай, многословные объявления переменных — здравствуй, var !

Java 8 vs Java 21 — Часть 1

Одно из самых заметных улучшений при переходе с Java 8 на современные версии — это введение локальной типовой инференции, более известной как ключевое слово var. Появившееся в Java 10, это нововведение устраняет избыточные объявления типов и делает код чище и читаемее.

Проблема Java 8
В Java 8 приходилось явно указывать тип каждой локальной переменной, даже когда он был очевиден из контекста:

// Java 8 - Verbose and redundant
Map<String, List<Customer>> customersByCity = new HashMap<String, List<Customer>>();
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Optional<Customer> customer = customerService.findById(123L);

Эта многословность становилась особенно болезненной при работе с:

- сложными обобщёнными типами,
- шаблонами Builder,
- потоковыми операциями со сложными промежуточными типами.

Решение в Java 21
С var компилятор автоматически выводит тип:

// Java 21 - Clean and concise
var customersByCity = new HashMap<String, List<Customer>>();
var names = Arrays.asList("Alice", "Bob", "Charlie");
var customer = customerService.findById(123L); 

Примеры из реальной практики

1. Работа с коллекциями

// Before (Java 8)
List<Map<String, Object>> configurations = new ArrayList<Map<String, Object>>();
Map<String, List<ValidationResult>> validationResults = new ConcurrentHashMap<String, List<ValidationResult>>();

// After (Java 21)
var configurations = new ArrayList<Map<String, Object>>();
var validationResults = new ConcurrentHashMap<String, List<ValidationResult>>(); 

2. Шаблоны проектирования

// Before (Java 8)
HttpURLConnection connection = (HttpURLConnection) new URL("https://api.example.com")
    .openConnection();

// After (Java 21)
var connection = (HttpURLConnection) new URL("https://api.example.com")
    .openConnection(); 
```Java

3. Потоковые операции

```Java
// Before (Java 8)
Stream<String> filteredNames = customers.stream()
    .map(Customer::getName)
    .filter(name -> name.startsWith("A"));

// After (Java 21)
var filteredNames = customers.stream()
    .map(Customer::getName)
    .filter(name -> name.startsWith("A")); 

Когда использовать var (лучшие практики)
✅ Хорошие случаи использования:

// Clear from initialization
var users = new ArrayList<User>();
var config = ConfigurationBuilder.create().build();
var response = httpClient.execute(request);

// With method calls that have descriptive names
var isValid = validator.validateEmail(email);
var totalAmount = calculator.computeTotal(items); 

❌ Избегайте использования, когда:

// Type is not obvious
var data = processData(); // What type is this?
var result = calculate(); // Unclear return type

// Primitives where explicitness helps
int count = 0; // Better than var count = 0;
boolean isActive = true; // Better than var isActive = true; 

Стратегия миграции
Постепенный подход к внедрению:

- Начните с очевидных случаев: сложные обобщённые типы, шаблоны Builder.
- Сфокусируйтесь на читаемости: используйте var там, где он улучшает восприятие кода.
- Поддерживайте единообразие: выработайте командные правила использования var.
- Проводите ревью и рефакторинг: обновляйте существующий код в процессе регулярного сопровождения.

Поддержка в IDE:
Большинство современных IDE отлично работают с var:

- IntelliJ IDEA: предлагает подсказки и отображает выведенные типы.
- Eclipse: показывает информацию о типе при наведении курсора.
- VS Code: расширения для Java поддерживают отображение выведенных типов.

Влияние на производительность
var — это исключительно функция времени компиляции, без какого‑либо накладного расхода во время выполнения. Сгенерированный байткод полностью идентичен коду с явно указанными типами.

👉@BookJava

Распространённые заблуждения

❌ «var делает Java динамически типизированным»
Неверно: Java остаётся статически типизированным языком. Компилятор по‑прежнему проверяет типы на этапе компиляции.

❌ «var ухудшает производительность»
Неверно: Никакого влияния на выполнение. Это всего лишь синтаксический сахар.

❌ «var снижает читаемость кода»
Зависит: При правильном использовании — улучшает читаемость, убирая лишний шум. При чрезмерном — может сделать код менее понятным.

Чек‑лист быстрой миграции

[ ] Найдите многословные объявления переменных в кодовой базе
[ ] Замените очевидные случаи на var (сложные дженерики, builders)
[ ] Установите командные правила использования var
[ ] Обновите процессы код‑ревью с учётом лучших практик применения var
[ ] Используйте возможности IDE для проверки выведенных типов

Итог
Локальная типовая инференция с var — небольшое изменение, которое значительно улучшает читаемость кода и опыт разработчика. Речь не о том, чтобы писать меньше кода, а о том, чтобы писать более понятный и поддерживаемый код, избавляясь от избыточных объявлений типов.

Начните использовать var уже сегодня — и сразу заметите, насколько чище станет ваш Java‑код!

👉@BookJava

🧠 Можно ли переопределить getClass() в Java?

Нет, нельзя.
Метод getClass() в java.lang.Object объявлен так:

public final native Class<?> getClass();

📌 Почему:

- final — запрещает переопределение в наследниках.
- native — реализован в JVM, а не на Java.
- Гарантирует, что при вызове obj.getClass() всегда вернётся реальный класс объекта, без подмен и сюрпризов.

💡 Если хотите вернуть “свой” тип, делайте отдельный метод:

class MyClass {
    public String getTypeName() {
        return "CustomType";
    }
}

⚠️ Переопределяемый getClass() сломал бы рефлексию, сериализацию и кучу системных механизмов. Именно поэтому Java защищает его.

👉 @BookJava