🤔 Для чего нужен функциональный интерфейс BiConsumer<T,U>?

BiConsumer<T, U> — это функциональный интерфейс из пакета java.util.function, который принимает два входных аргумента и не возвращает результат.

Сигнатура BiConsumer<T, U>

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

🚩Вывод пар значений

Допустим, у нас есть Map<String, Integer>, и мы хотим вывести все ключи и значения:

import java.util.Map;
import java.util.function.BiConsumer;

public class BiConsumerExample {
    public static void main(String[] args) {
        Map<String, Integer> map = Map.of("Alice", 30, "Bob", 25, "Charlie", 35);

        // Используем BiConsumer для вывода ключа и значения
        BiConsumer<String, Integer> printEntry = (key, value) -> 
            System.out.println("Имя: " + key + ", возраст: " + value);

        // Применяем BiConsumer к каждому элементу Map
        map.forEach(printEntry);
    }
}

Вывод

Имя: Alice, возраст: 30  
Имя: Bob, возраст: 25  
Имя: Charlie, возраст: 35  

🚩Использование `BiConsumer` в `Stream`

Допустим, у нас есть список продуктов и их цены. Мы хотим увеличить цену каждого товара и напечатать результат.

import java.util.*;
import java.util.function.BiConsumer;

public class BiConsumerStreamExample {
    public static void main(String[] args) {
        Map<String, Double> products = new HashMap<>();
        products.put("Хлеб", 50.0);
        products.put("Молоко", 80.0);
        products.put("Яблоки", 120.0);

        // BiConsumer, который увеличивает цену и выводит её
        BiConsumer<String, Double> increaseAndPrint = (name, price) -> {
            double newPrice = price * 1.1; // +10%
            System.out.println(name + " теперь стоит " + newPrice);
        };

        products.forEach(increaseAndPrint);
    }
}

Вывод

Хлеб теперь стоит 55.0  
Молоко теперь стоит 88.0  
Яблоки теперь стоят 132.0  

🚩Объединение `BiConsumer` с `andThen()`

Метод andThen(BiConsumer<T, U>) позволяет объединять несколько действий в цепочку.

import java.util.function.BiConsumer;

public class BiConsumerChaining {
    public static void main(String[] args) {
        BiConsumer<String, Integer> printUser = (name, age) -> 
            System.out.println("Пользователь: " + name + ", возраст: " + age);

        BiConsumer<String, Integer> checkAdult = (name, age) -> 
            System.out.println(name + (age >= 18 ? " совершеннолетний" : " несовершеннолетний"));

        // Объединяем два BiConsumer'а
        BiConsumer<String, Integer> combined = printUser.andThen(checkAdult);

        combined.accept("Алексей", 20);
        combined.accept("Мария", 16);
    }
}

Вывод:

Пользователь: Алексей, возраст: 20  
Алексей совершеннолетний  
Пользователь: Мария, возраст: 16  
Мария несовершеннолетний

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что произойдёт, если в блоке инициализации возникнет исключительная ситуация?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Чем отличается обычный объект от Bean?

В Spring термин Bean (бин) означает объект, управляемый Spring-контейнером.

🟠Обычный объект (Java POJO)
Создаётся вручную, Spring о нём ничего не знает

class Car {
    void drive() {
        System.out.println("Машина едет...");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car(); // Создаём объект вручную
        car.drive();
    }
}

🟠Spring Bean (управляемый объект)
Spring создаёт и управляет бином через аннотации.

import org.springframework.stereotype.Component;

@Component  // Сообщает Spring, что этот класс - Bean
class Car {
    void drive() {
        System.out.println("Spring-машина едет...");
    }
}

Теперь объект создаётся Spring-контейнером

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class); // Получаем Bean из Spring-контейнера
        car.drive();
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём смысл ReadWriteLock?

ReadWriteLock:
- Разделяет доступ на чтение и запись:
- Несколько потоков могут читать одновременно.
- Но только один поток может записывать (и блокирует чтение).
- Повышает производительность при преобладании операций чтения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему строки так часто используют в виде ключей в HashMap?

Использование строк в качестве ключей в HashMap очень распространено, потому что строки обладают рядом свойств, которые идеально подходят для этой задачи. Вот основные причины:

🟠Строки неизменяемы
Что это значит: После создания строка не может быть изменена (все операции над строками создают новый объект).
Почему это важно: Ключ в HashMap должен быть неизменяемым, потому что, если ключ изменится после его добавления, это нарушит работу хэш-таблицы. Например, HashMap больше не сможет найти объект по этому ключу.

  HashMap<String, Integer> map = new HashMap<>();
  String key = "hello";
  map.put(key, 1);
  // key остается "hello", ничего не ломается
  

🟠Эффективный `hashCode` и `equals`
Что это значит: Класс String в Java имеет качественно реализованные методы hashCode() и equals(), которые оптимизированы для работы с большими наборами данных.
Почему это важно: Эти методы определяют, куда ключ попадет в HashMap (по хэш-коду) и сравнивают ключи (по equals), чтобы избежать коллизий.
Особенность: Алгоритм hashCode() у строки быстро вычисляет хэш-код на основе её символов.

  String str1 = "hello";
  String str2 = "hello";
  System.out.println(str1.hashCode() == str2.hashCode()); // true
  

🟠Простота использования
Что это значит: Строки легко создавать, читать и понимать. Они часто используются для идентификаторов (например, имён, адресов, кодов).
Почему это важно: Программистам удобно использовать строки в качестве ключей, потому что их легко интерпретировать.

🟠Универсальность
Что это значит* Строки могут представлять самые разные данные — от имён и кодов до сложных текстовых идентификаторов.
Почему это важно: Почти любой объект или данные можно однозначно представить в виде строки, что делает её универсальным кандидатом на роль ключа.

🟠Широкая поддержка
Что это значит: Почти все приложения и API Java оперируют строками.
Почему это важно: Это упрощает интеграцию строк как ключей в сложных системах.

🚩Пример использования строки в качестве ключа

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> ageMap = new HashMap<>();
        ageMap.put("Alice", 30);
        ageMap.put("Bob", 25);
        ageMap.put("Charlie", 35);

        // Получаем значение по строковому ключу
        System.out.println("Возраст Боба: " + ageMap.get("Bob")); // 25
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что будет если в ApplicationContext попробуешь получить один и тот же бин?

Если бин имеет скоуп singleton (по умолчанию), ApplicationContext вернёт одну и ту же инстанцию бина при каждом запросе.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 К какому принципу ООП относится переопределение методов?

Переопределение методов (Method Overriding) относится к полиморфизму – одному из ключевых принципов ООП.

🚩Как работает переопределение (`@Override`)?

Переопределение (Overriding) – это когда подкласс изменяет поведение метода родительского класса.

class Animal {
    void makeSound() {
        System.out.println("Какое-то животное издаёт звук");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Гав-гав!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Мяу!");
    }
}

Используем полиморфизм

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // Полиморфизм
        myAnimal.makeSound(); // Выведет "Гав-гав!"
    }
}

🚩Переопределение = полиморфизм времени выполнения (Runtime Polymorphism)

Перегрузка (Overloading) – полиморфизм времени компиляции (Compile-time).
Переопределение (Overriding) – полиморфизм времени выполнения (Runtime).

🚩Когда нужно переопределять методы?

Когда подкласс должен изменить поведение родительского класса.
Когда работаем с абстрактными классами и интерфейсами.
Когда используем полиморфизм для гибкости кода.

Ставь 👍 и забирай 📚 Базу знаний

Пожизненная PRO подписка на easyoffer по цене одного года.

Акция до 20 февраля. Покупаешь сейчас один раз – пользуешься всю жизнь без лимита, включая все будущие функции.

Запланированные новые фичи на ближайшие пол года:
1. Агрегатор вакансий
2. Улучшение резюме, чтобы проходить ATS системы
3. Генерация уникального резюме и сопроводительного письма под вакансию

Покупай на https://easyoffer.ru/

🤔 Что находится внутри у HashSet и TreeSet?

- HashSet внутри использует HashMap. Элементы хранятся как ключи, а значения — фиктивные (Object PRESENT = new Object()).
- TreeSet основан на TreeMap, который реализован через самобалансирующееся красно-чёрное дерево. Элементы сортируются по Comparable или переданному Comparator.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что лежит в основе Spring?

В основе фреймворка Spring лежит концепция инверсии управления (IoC, Inversion of Control) и внедрения зависимостей (DI, Dependency Injection). Эти принципы обеспечивают гибкость, расширяемость и удобство в управлении зависимостями между компонентами приложения, делая код более модульным, тестируемым и поддерживаемым.

🚩Инверсия управления (IoC)

Это парадигма, при которой контроль над выполнением программы частично или полностью передаётся фреймворку или библиотеке. В контексте Spring IoC означает, что сам фреймворк управляет созданием объектов и их жизненным циклом, а не программист напрямую. Это достигается через использование "контейнера IoC", который автоматически создаёт и связывает объекты в соответствии с конфигурацией приложения, заданной в XML-файлах, аннотациях или Java-конфигурации.

🚩Внедрение зависимостей (DI)

Это техника реализации IoC, при которой объектам "внедряются" или "предоставляются" их зависимости извне. Вместо того чтобы компоненты приложения самостоятельно создавали или искали необходимые им объекты (зависимости), Spring контейнер автоматически предоставляет им все необходимые зависимости в момент создания объекта. Это уменьшает связность между компонентами и упрощает управление зависимостями, а также их изменение и тестирование.

🚩Основные компоненты

🟠Spring Core Container
Включает в себя IoC и DI, обеспечивая основу для фреймворка.
🟠Spring AOP (Aspect-Oriented Programming)
Позволяет реализовывать поперечные задачи (например, логирование, транзакции) в виде аспектов, не изменяя основной бизнес-логики.
🟠Spring MVC
Фреймворк для создания веб-приложений по модели MVC.
🟠Spring Boot
Предоставляет набор инструментов для быстрой разработки и запуска приложений с минимальной конфигурацией.
🟠Spring Data
Упрощает доступ к данным, работу с базами данных и операциями CRUD.
🟠Spring Security
Предоставляет комплексные средства безопасности для аутентификации и авторизации.

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём разница между HashMap и WeakHashMap?

- HashMap удерживает ключи сильно → не GC;
- WeakHashMap — ключи GC-способны, могут быть удалены, если больше нигде не используются.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как устроена память JVM?

JVM (Java Virtual Machine) управляет памятью приложения и делит её на несколько областей.

🟠Heap (Куча) – область для объектов
Здесь хранятся ВСЕ объекты и массивы, созданные через new.
Управляется Garbage Collector (GC)

🟠Stack (Стек) – область для методов и переменных
Локальные переменные (int, double, String – если не new)
Ссылки на объекты в Heap
Вызовы методов (кадры стека)

public class StackExample {
    public static void main(String[] args) {
        int a = 5;
        int b = sum(a, 10);
    }

    public static int sum(int x, int y) {
        return x + y;
    }
}

🟠Metaspace – метаданные классов
Хранит информацию о загруженных классах (названия, методы, поля, байт-код).
При загрузке нового класса ClassLoader выделяет память в Metaspace.
В Java 8 заменил устаревший PermGen.

while (true) {
    ClassLoader loader = new MyClassLoader();
    Class<?> clazz = loader.loadClass("MyDynamicClass");
}

🟠Program Counter (PC Register)
Хранит адрес текущей инструкции, выполняемой потоком.
У каждого потока свой PC Register.
Работает как указатель в машинном коде.

🟠Native Method Stack
Хранит данные, связанные с вызовами нативных методов (JNI – Java Native Interface).
Если Java вызывает C++-код, информация о вызове хранится здесь.

public class NativeExample {
    public native void callCMethod();
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Каким образом передаются переменные в методы?

В Java всё передаётся по значению:
- Примитивы передаются как копии значений.
- Объекты — как копии ссылок, то есть метод работает с тем же объектом, но не может изменить саму ссылку.
Изменения внутри метода влияют на поля объекта, но не на саму переменную-ссылку.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Массив — статическая структура данных или динамическая?

🟠Почему массив – статическая структура?
Фиксированный размер – при создании массива его длина задаётся раз и навсегда.
Нельзя изменить размер – нельзя добавить или удалить элементы после создания массива.

int[] numbers = new int[5]; // Размер 5, изменить нельзя!

🟠Что делать, если нужен динамический массив?
В Java есть динамические структуры данных, например ArrayList.

import java.util.ArrayList;
import java.util.List;

public class DynamicArrayExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        
        list.add(1);
        list.add(2);
        list.add(3);
        
        System.out.println(list); // [1, 2, 3]
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Почему появился HashMap?

HashMap решает задачи:
- Быстрого доступа к данным по ключу (в среднем за O(1)).
- Работает эффективнее, чем List или Set, при необходимости хранения пары ключ-значение.
- Позволяет гибко организовать кэш, справочники, индексированные хранилища.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какая сложность поиска метода по ключу в коллекции TreMap?

В TreeMap поиск элемента по ключу выполняется за O(log n).

🚩Почему сложность `O(log n)`?

TreeMap основан на красно-чёрном дереве (Red-Black Tree).
Красно-чёрное дерево – это самобалансирующееся бинарное дерево.
В худшем случае, глубина дерева ≈ log₂(n), поэтому:
Поиск (get(key)) выполняется за O(log n).
Вставка (put(key, value)) тоже O(log n), так как требует балансировки.

import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(10, "Ten");
        treeMap.put(20, "Twenty");
        treeMap.put(30, "Thirty");

        System.out.println(treeMap.get(20)); // Поиск за O(log n)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Сравни интерфейсы Queue и Deque.

- Queue — интерфейс однонаправленной очереди (FIFO);
- Deque — интерфейс двунаправленной очереди, расширяющий Queue, добавляет методы для работы с двумя концами (addFirst, pollLast, и т.д.).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Слышал ли что то про цикл ForEach?

Цикл forEach – это удобный способ перебора элементов коллекций в Java.

🚩Что такое `forEach`?

Это специальный цикл, который упрощает перебор элементов коллекций и массивов. Он пришёл на замену классическому for и while, делая код чище.

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

for (int i = 0; i < names.size(); i++) {
    System.out.println(names.get(i));
}

Современный forEach

for (String name : names) {
    System.out.println(name);
}

🚩`forEach` как метод (Java 8+)

С выходом Java 8 в интерфейсе Iterable появился метод forEach(), который принимает лямбда-выражение.

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

names.forEach(name -> System.out.println(name));

Или с ссылкой на метод (::)

names.forEach(System.out::println);

🚩Как работает `forEach()` с Map?

Метод forEach() можно применять и к Map, передавая BiConsumer<K, V>.

Map<Integer, String> users = Map.of(1, "Alice", 2, "Bob");

users.forEach((id, name) -> System.out.println(id + " -> " + name));

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие есть общие стратегии ветвления?

- Git Flow (feature, release, hotfix ветви);
- GitHub Flow (основная ветка + короткоживущие feature-ветки);
- Trunk-Based Development (минимум ветвлений, быстрое слияние в мастер).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 В чем разница между шаблоном проектирования Builder и Facade?

🚩`Builder` – создание сложных объектов

Когда у объекта много параметров.
Когда объект трудно создавать через конструктор.

class Car {
    private String engine;
    private int wheels;
    private boolean sunroof;

    private Car(CarBuilder builder) {
        this.engine = builder.engine;
        this.wheels = builder.wheels;
        this.sunroof = builder.sunroof;
    }

    public static class CarBuilder {
        private String engine;
        private int wheels;
        private boolean sunroof;

        public CarBuilder setEngine(String engine) {
            this.engine = engine;
            return this;
        }

        public CarBuilder setWheels(int wheels) {
            this.wheels = wheels;
            return this;
        }

        public CarBuilder setSunroof(boolean sunroof) {
            this.sunroof = sunroof;
            return this;
        }

        public Car build() {
            return new Car(this);
        }
    }
}

Создаём объект пошагово

Car car = new Car.CarBuilder()
    .setEngine("V8")
    .setWheels(4)
    .setSunroof(true)
    .build();

🚩`Facade` – упрощение сложной системы

Когда у системы много сложных классов, и вы хотите предоставить один упрощённый интерфейс.
Когда нужно скрыть детали реализации от клиента.

class CPU {
    void start() { System.out.println("Процессор запущен."); }
}

class Memory {
    void load() { System.out.println("Память загружена."); }
}

class HardDrive {
    void read() { System.out.println("Чтение данных с диска."); }
}

Создаём Facade, который скрывает сложность

class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    private HardDrive hardDrive;

    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.hardDrive = new HardDrive();
    }

    public void startComputer() {
        cpu.start();
        memory.load();
        hardDrive.read();
        System.out.println("Компьютер включен!");
    }
}

Теперь клиенту не нужно вызывать кучу методов

ComputerFacade computer = new ComputerFacade();
computer.startComputer(); // Запускает всю систему через 1 метод

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём смысл ограничений?

Ограничения (constraints) — это механизмы обеспечения целостности данных в базе. Они не дают ввести ошибочные или противоречивые данные, повышают надёжность и предсказуемость системы.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний