🖥️ 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 всегда передает данные по значению!
🔹 Примитивы передаются как копии значений.
🔹 Объекты передаются как копии ссылок, но изменения внутри объекта сохраняются.
🔹 Если внутри метода изменить саму ссылку, это не повлияет на оригинальный объект.

📲 Мы в MAX

👉@BookJava

Совет по Java 💡☕️

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

📲 Мы в MAX

👉@BookJava

🚀 Совет по Java API 🚀

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

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

📲 Мы в MAX

👉@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 исключения: Не контролируются компилятором, часто возникают из-за ошибок в коде и могут привести к аварийному завершению программы, если не обработаны.

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

📲 Мы в MAX

👉@BookJava

🚀Разбираем принцип работы 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
    }
}

📲 Мы в MAX

👉@BookJava

🔴 Завтра тестовое собеседование с Java-разработчиком

1 апреля(уже завтра!) в 19:00 по мск приходи онлайн на открытое собеседование, чтобы посмотреть на настоящее интервью на Middle Java-разработчика.

Как это будет:
📂 Виктор Анохин, старший разработчик из WildBerries, будет задавать реальные вопросы и задачи разработчику-добровольцу
📂 Виктор будет комментировать каждый ответ респондента, чтобы дать понять чего от вас ожидает собеседующий на интервью
📂 В конце можно будет задать любой вопрос Виктору

Это бесплатно. Эфир проходит в рамках менторской программы от ШОРТКАТ для Java-разработчиков, которые хотят повысить свой грейд, ЗП и прокачать скиллы.

Переходи в нашего бота, чтобы получить ссылку на эфир → @shortcut_sh_bot

Реклама.
О рекламодателе.

🚀Как правильно использовать 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? Пишите в комментариях! 🚀

📲 Мы в MAX

👉@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.


📲 Мы в MAX

👉@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 в своих проектах? Делитесь опытом! 🚀

📲 Мы в MAX

👉@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.


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

📲 Мы в MAX

👉@BookJava