Что делает принцип happens before в рамках многопоточности ?
Спросят с вероятностью 12%

Принцип "happens-before" в контексте многопоточности определяет правила, при которых одно действие (операция чтения или записи переменной) считается предшествующим другому действию в исполнении программы. Это ключевой механизм для обеспечения видимости изменений, сделанных одним потоком, другими потоками, а также для гарантии корректной синхронизации между потоками без возникновения гонок данных (race conditions).

Этот принцип устанавливает порядок действий таким образом, что если действие A happens-before действия B, то все изменения, сделанные в A, будут видны в B (и не наоборот). Это не обязательно означает, что A физически выполняется до B, но с точки зрения видимости изменений и порядка операций, JVM и аппаратное обеспечение гарантируют, что B увидит результаты, произведённые A.

Ключевые правила:

1️⃣Правило программного порядка: Операции внутри одного потока выполняются в порядке их программирования. Операции, выполненные ранее в потоке, happens-before операций, выполненных позже.

2️⃣Правило блокировки монитора: Освобождение монитора (выход из синхронизированного блока) happens-before последующего захвата этого же монитора другим потоком.

3️⃣Правило volatile переменных: Запись в volatile переменную happens-before любых последующих чтений этой же переменной другими потоками.

4️⃣Правило передачи по ссылке: Если поток A копирует переменную doSomething в threadB.start(), и threadB видит значение doSomething при запуске, то все действия в A до копирования happens-before действий в threadB.

5️⃣Правило начала потока: Все действия в потоке happens-before любого действия в другом потоке, которое видит, что первый поток был запущен.

6️⃣Правило завершения потока: Все действия в потоке happens-before того, как другой поток успешно возвращает результат из Thread.join() на завершившемся потоке.

Значение принципа:

Этот принцип позволяет понимать и предсказывать поведение многопоточных программ, обеспечивая корректное взаимодействие между потоками. Соблюдение "happens-before" помогает избежать проблем с согласованностью данных, когда изменения, сделанные одним потоком, могут не быть видны другому потоку, что может привести к непредсказуемому поведению программы.

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Как организована HashMap ?
Спросят с вероятностью 56%

HashMap — это структура данных, которая использует хеш-таблицу для хранения пар "ключ-значение". Gозволяет выполнять операции вставки, удаления и поиска элементов с почти постоянным временем выполнения, что делает её очень эффективной для определённых задач. Вот как она организована:

Внутреннее устройство

1️⃣ Хеш-функция: Ключи хранятся с использованием хеш-функции, которая преобразует ключ в индекс массива. Этот индекс используется для хранения значения в массиве. Она должна равномерно распределять ключи по индексам массива, чтобы минимизировать коллизии.

2️⃣ Массив бакетов (корзин): Внутри, она состоит из массива бакетов, где каждый бакет представляет собой "корзину", которая может хранить одну или более пар "ключ-значение". При добавлении новой пары "ключ-значение", хеш-функция вычисляет индекс бакета для хранения значения на основе хеш-кода ключа.

3️⃣ Связный список или дерево: В случае коллизии, когда два разных ключа имеют одинаковый хеш-код и попадают в один и тот же бакет, HashMap использует структуру данных в виде связного списка или дерева для хранения и разрешения коллизий. После определённого порога коллизий, список преобразуется в дерево для улучшения производительности поиска в этом бакете.

Работа

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

- Поиск: Поиск значения по ключу также начинается с вычисления хеш-кода ключа, определения индекса бакета и последующего поиска в связном списке или дереве этого бакета.

- Удаление: Удаление пары "ключ-значение" происходит аналогично поиску: сначала находится бакет, затем в нём ищется и удаляется элемент.

Расширение

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

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое Dispatcher Servlet ?
Спросят с вероятностью 12%

DispatcherServlet является ключевым компонентом, который работает как фронтальный контроллер (front controller) в паттерне проектирования MVC (Model-View-Controller) для веб-приложений. Он управляет всем процессом маршрутизации входящих HTTP запросов к соответствующим обработчикам (контроллерам), а также управляет дальнейшим процессом отображения результатов работы этих обработчиков.

Как он работает:

1️⃣Прием запроса: Принимает все входящие HTTP запросы к приложению.

2️⃣Определение обработчика: Он определяет, какой контроллер должен обработать запрос, на основе конфигурации маршрутов (URL mappings).

3️⃣Делегирование запроса: Затем он делегирует запрос выбранному контроллеру.

4️⃣Обработка запроса: Контроллер обрабатывает запрос и возвращает модель (данные) и имя представления (view) назад к DispatcherServlet.

5️⃣Отображение представления: Передает модель в представление (view), которое генерирует финальный HTML (или другой формат) для клиента.

6️⃣Отправка ответа: Наконец, он отправляет ответ клиенту.

Преимущества использования:

✅Централизованное управление: Предоставляет единую точку входа для всех запросов к приложению, что упрощает конфигурацию и управление маршрутизацией.

✅Гибкая маршрутизация: Позволяет легко определить маршруты, параметры URL и другие аспекты маршрутизации с помощью аннотаций или XML конфигурации.

✅Поддержка различных типов ответов: Поддерживает генерацию различных типов ответов — от HTML страниц до JSON или XML данных для REST API.

✅Обработка исключений: Обеспечивает централизованную обработку исключений, что позволяет удобно управлять ошибками на уровне приложения.

✅Интеграция с другими компонентами Spring: Легко интегрируется с другими компонентами и сервисами Spring, такими как Spring Security, Spring Data и т.д.

В традиционном веб-приложении на базе Spring DispatcherServlet обычно конфигурируется в файле web.xml или через Java-конфигурацию в приложениях на Spring Boot, где DispatcherServlet автоматически настраивается без необходимости явного определения.

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое иерархия коллекций ?
Спросят с вероятностью 62%

Иерархия коллекций — это набор интерфейсов и классов, которые предоставляют общие структуры данных, такие как списки, множества и карты. Находится в пакете java.util и разработана для работы с группами объектов.

Основные интерфейсы:

- Collection Interface: Корневой интерфейс иерархии коллекций. Определяет методы, такие как add(), remove(), size(), isEmpty() и iterator(), которые должны быть реализованы всеми коллекциями.

- List Interface: Представляет упорядоченную коллекцию. Элементы в списке могут быть доступны по индексам. Допускает дублирование элементов. Реализации включают ArrayList, LinkedList и Vector.

- Set Interface: Набор уникальных элементов. Не допускает дублирования элементов. Реализации включают HashSet, LinkedHashSet и TreeSet.

- Queue Interface: Для работы с коллекциями, используемыми для хранения элементов перед обработкой. Поддерживает операции вставки, извлечения и инспекции. LinkedList реализует как List, так и Queue. Также есть PriorityQueue для элементов, которые должны обрабатываться в порядке приоритета.

- Map Interface: Не наследуется от Collection интерфейса. Описывает структуру для хранения пар ключ/значение. Ключи уникальны, а значения могут дублироваться. Реализации включают HashMap, LinkedHashMap, TreeMap и Hashtable.

Особенности классов:

- ArrayList: Динамический массив для хранения элементов, который автоматически расширяется. Предлагает быстрый доступ к элементам по индексу.

- LinkedList: Двусвязный список, который обеспечивает эффективное добавление/удаление элементов. Может использоваться как список и очередь.

- HashSet: Использует хеш-таблицу для хранения уникальных элементов. Не гарантирует порядок элементов.

- LinkedHashSet: Расширяет HashSet, сохраняя порядок вставки элементов.

- TreeSet: Хранит элементы в отсортированном и восходящем порядке. Использует красно-черное дерево.

- HashMap: Хеш-таблица для хранения пар ключ/значение. Не поддерживает упорядоченность ключей или значений.

- LinkedHashMap: Расширяет HashMap, сохраняя порядок вставки ключей.

- TreeMap: Реализует красно-черное дерево, сохраняет ключи в отсортированном порядке.

- PriorityQueue: Элементы добавляются согласно их приоритету, определенному компаратором.

Суть иерархии коллекций

Иерархия коллекций обеспечивает унифицированный способ работы с различными типами данных. Она предоставляет гибкость для выбора подходящей структуры данных в зависимости от требований к производительности, порядку элементов и уникальности значений. Использование этих коллекций позволяет разработчикам эффективно хранить, извлекать, удалять и обрабатывать данные в Java-приложениях.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Как "под капотом" работает аннотация transactional ?
Спросят с вероятностью 12%

Аннотация @Transactional предоставляет мощный и гибкий способ управления транзакциями приложениях. Используя эту аннотацию, разработчики могут декларативно управлять границами транзакций на уровне классов или методов, не заботясь о низкоуровневых операциях управления транзакциями. Вот как он работает:

1️⃣ Прокси

При старте приложения он сканирует компоненты на предмет наличия аннотации @Transactional и создаёт для них прокси-объекты. Эти прокси используются для перехвата вызовов к методам, отмеченным аннотацией. В зависимости от настроек, прокси может быть основан на JDK динамических прокси (для интерфейсов) или на CGLIB прокси (для классов).

2️⃣ Перехват вызовов

Когда вызывается метод, отмеченный @Transactional, прокси перехватывает этот вызов и начинает управление транзакцией. Если транзакция уже существует, он решает, присоединиться к этой транзакции или создать новую, основываясь на атрибутах аннотации (например, propagation).

3️⃣ Управление транзакцией

Делегирует управление транзакцией менеджеру транзакций (PlatformTransactionManager), специфичному для используемой технологии доступа к данным (JPA, JDBC, Hibernate и т.д.). Менеджер транзакций отвечает за начало, коммит и откат транзакции.

4️⃣ Исполнение бизнес-логики

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

5️⃣ Атрибуты аннотации

Аннотация @Transactional позволяет настраивать различные аспекты управления транзакцией, включая:
- propagation — правила распространения транзакций;
- isolation — уровень изоляции транзакции;
- readOnly — указывает, является ли транзакция только для чтения;
- timeout — максимальное время выполнения транзакции;
- rollbackFor и noRollbackFor — классы исключений, при которых транзакция должна быть откачена или не откачена.

Аннотация @Transactional упрощает управление транзакциями, позволяя разработчикам фокусироваться на бизнес-логике, в то время как Spring заботится о транзакционной границе и корректном управлении транзакциями "под капотом". Важно правильно настраивать атрибуты аннотации и понимать механизмы работы транзакций, чтобы обеспечить надёжность и производительность приложения.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое Parallel Stream ?
Спросят с вероятностью 12%

Parallel Stream является частью Java Stream API, который представлен. Это мощное средство для выполнения параллельной обработки данных, позволяя разработчикам легко писать многопоточный код. Он использует ForkJoinPool, который по умолчанию создаёт столько рабочих потоков, сколько у вас ядер процессора, для разделения задачи на подзадачи и их параллельной обработки, а затем объединения результатов. Это позволяет значительно ускорить выполнение операций с большими объёмами данных за счёт распараллеливания вычислений.

Как он работает

Когда вы вызываете метод parallelStream() на коллекции или используете метод parallel() на потоке данных, Java автоматически старается распараллелить выполнение операций над этим потоком данных. Однако степень ускорения, которую можно получить, сильно зависит от количества данных, типа выполняемых операций и доступных системных ресурсов.

Пример:

List<String> strings = Arrays.asList("one", "two", "three", "four");
List<String> result = strings.parallelStream()
                             .map(String::toUpperCase)
                             .collect(Collectors.toList());

В этом примере parallelStream() используется для создания параллельного потока из списка строк, каждая строка преобразуется в верхний регистр с помощью метода map, а результат собирается обратно в список.

Важные моменты:

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

✅ Побочные эффекты: При использовании параллельных потоков следует избегать операций, имеющих побочные эффекты (например, изменение состояния внешних переменных), так как это может привести к непредсказуемому поведению.

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

Parallel Stream — это мощный инструмент для ускорения обработки больших объёмов данных за счёт параллельного выполнения операций. Однако его эффективность зависит от множества факторов, и его использование требует понимания особенностей параллельной обработки данных.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Какие знаешь варианты dependency injectio ?
Спросят с вероятностью 12%

Внедрение зависимостей (Dependency Injection, DI) — это ключевой принцип в разработке ПО, позволяющий уменьшить связность между компонентами программы и упростить их тестирование. DI может быть реализовано различными способами, в зависимости от используемых технологий и фреймворков. Существуют следующие основные способы внедрения зависимостей:

1️⃣Внедрение через конструктор (Constructor Injection)

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

@Component
public class MyService {
    private final Dependency dependency;

    @Autowired
    public MyService(Dependency dependency) {
        this.dependency = dependency;
    }
}

2️⃣Внедрение через сеттер (Setter Injection)

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

@Component
public class MyService {
    private Dependency dependency;

    @Autowired
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

3️⃣Внедрение через поля (Field Injection)

Непосредственно в поля класса без использования сеттеров или конструктора. Хотя это удобно и уменьшает количество кода, такой подход может затруднить тестирование и не гарантирует завершённость состояния объекта после его создания.

@Component
public class MyService {
    @Autowired
    private Dependency dependency;
}

4️⃣Внедрение через методы (Method Injection)

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

@Component
public class MyService {
    private Dependency dependency;

    @Autowired
    public void initialize(Dependency dependency) {
        this.dependency = dependency;
    }
}

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

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что значит реляционная база данных ?
Спросят с вероятностью 12%

Реляционная база данных — это тип базы данных, основанный на реляционной модели, которую предложил Эдгар Ф. Кодд в 1970 году. В реляционной базе данных данные хранятся в таблицах (иногда называемых реляциями), которые состоят из рядов и столбцов. Каждая таблица представляет собой набор связанных данных, а каждый ряд в таблице представляет собой одну запись, содержащую уникальный идентификатор, известный как первичный ключ (Primary Key), и значения в столбцах, представляющие атрибуты этой записи.

Основные принципы:

1️⃣ Структура данных: Данные организованы в таблицы. Каждая таблица состоит из рядов (записей) и столбцов (полей). Каждый столбец в таблице предназначен для определённого типа данных.

2️⃣ Целостность данных: Поддерживает правила целостности, которые обеспечивают точность и надёжность данных. Основные виды целостности включают целостность сущностей (каждая запись имеет уникальный идентификатор) и целостность ссылок (связи между таблицами поддерживаются через внешние ключи).

3️⃣ Манипулирование данными: Для управления данными используются языки запросов, такие как SQL (Structured Query Language), позволяющие выполнять запросы для выборки, вставки, обновления и удаления данных.

4️⃣ Нормализация: Процесс нормализации применяется для уменьшения избыточности и зависимости данных путём разделения больших таблиц на меньшие и определения отношений между ними. Это помогает улучшить производительность и упрощает обслуживание базы данных.

5️⃣ Транзакции: Поддерживают концепцию транзакций, что позволяет группировать несколько операций с данными в одну логическую единицу работы, которая либо полностью выполняется, либо полностью отменяется, обеспечивая тем самым целостность данных.

6️⃣ ACID-свойства: Гарантируют соблюдение ACID-свойств (Атомарность, Согласованность, Изолированность, Долговечность), что является ключом к надёжности и безопасности транзакций.

Примеры:

- MySQL
- PostgreSQL
- Oracle Database
- Microsoft SQL Server
- SQLite

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Зачем нужен Spring Framework ?
Спросят с вероятностью 19%

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

1️⃣ Упрощение разработки

Он упрощает создание сложных приложений, предоставляя шаблоны проектирования и кода для решения общих задач, таких как управление транзакциями, работа с базой данных, обработка веб-запросов и многое другое.

2️⃣ Dependency Injection (DI) и Inversion of Control (IoC)

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

3️⃣ Обширная поддержка данных

Фреймворк предлагает мощную поддержку для работы с базами данных, включая интеграцию с JPA (Java Persistence API), Hibernate и другими ORM (Object-Relational Mapping) технологиями. Он упрощает доступ к данным и уменьшает количество необходимого бойлерплейта.

4️⃣ Транзакционное управление

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

5️⃣ Модульность

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

6️⃣ Интеграция

Обеспечивает интеграцию с другими фреймворками и библиотеками, такими как JMS (Java Message Service), JMX (Java Management Extensions), электронной почтой, тасками, планированием и многим другим.

7️⃣ Поддержка веб-разработки

MVC (Model-View-Controller) предоставляет платформу для создания веб-приложений на стороне сервера, включая RESTful приложения, обеспечивая гибкость и мощные возможности.

8️⃣ Безопасность

Spring Security предлагает комплексные решения для аутентификации, авторизации, защиты от распространенных атак, таких как сессионный хайджекинг, кросс-сайтовый скриптинг и т.д.

9️⃣ Облачные и микросервисные архитектуры

Spring Boot и Spring Cloud предлагают решения для упрощения разработки микросервисных архитектур и облегчения развертывания приложений в облаке.

Spring Framework снимает множество распространенных проблем, с которыми можно столкнуться, и позволяет сосредоточиться на бизнес-логике приложения, что делает его одним из самых популярных и широко используемых фреймворков для разработки.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое dependency injection ?
Спросят с вероятностью 12%

Внедрение зависимостей (Dependency Injection, DI) — это дизайн-паттерн, используемый для уменьшения связности между компонентами программы, что упрощает их тестирование, развитие и поддержку. Этот паттерн достигается путём передачи зависимостей объекта (сервисов, которые он использует) извне, вместо их создания внутри самого объекта.

Принципы:

1️⃣Инверсия управления (Inversion of Control, IoC): Компоненты программы должны получать свои зависимости извне, а не создавать их самостоятельно. Это обеспечивает гибкость в замене зависимостей и упрощает управление их жизненным циклом.

2️⃣Внедрение зависимостей: Зависимости объекта предоставляются ему извне. Это может быть реализовано через конструктор (constructor injection), сеттеры (setter injection) или интерфейсы (interface injection).

Преимущества:

✅Уменьшение связности: Уменьшает связность между компонентами программы, делая их более независимыми и упрощая изменения и дополнения.
✅Улучшение тестируемости: Поскольку зависимости внедряются извне, для тестирования можно легко использовать мок-объекты вместо реальных зависимостей.
✅Гибкость и масштабируемость: Приложения, использующие его, легче модифицировать и масштабировать, поскольку изменение поведения компонентов можно достичь путём изменения внедряемых зависимостей.
✅Управление жизненным циклом: Фреймворки, предоставляющие его (например, Spring), могут управлять жизненным циклом объектов, включая создание, конфигурирование и уничтожение.

Без DI:

class MyService {
    private MyDependency dependency = new MyDependency();
}

С DI:

class MyService {
    private MyDependency dependency;
    
    MyService(MyDependency dependency) {
        this.dependency = dependency;
    }
}

В этом примере MyService больше не отвечает за создание своей зависимости MyDependency. Вместо этого зависимость передаётся в MyService, что упрощает замену MyDependency другой реализацией для тестирования или изменения поведения.

Dependency Injection — это мощный паттерн проектирования, который улучшает дизайн приложения за счёт уменьшения связности между его компонентами, облегчая тем самым их тестирование, развитие и поддержку.

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Какие знаешь Bean Scope ?
Спросят с вероятностью 12%

"Bean Scope" (область видимости бина) определяет жизненный цикл и видимость бинов (объектов, управляемых Spring IoC контейнером). Вот основные области видимости бинов:

1️⃣ Singleton

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

2️⃣ Prototype

Контейнер создаёт новый экземпляр бина каждый раз, когда он запрашивается. Это полезно, когда вам нужны независимые экземпляры объекта.

3️⃣ Request

Эта область видимости применяется только в веб-приложениях. Бин с областью видимости Request создаётся каждый раз при выполнении HTTP-запроса. Такой бин живёт в пределах одного запроса.

4️⃣ Session

Также используется в веб-приложениях. Бин с областью видимости Session создаётся на время жизни HTTP-сессии. Это означает, что бин связан с конкретной сессией пользователя.

5️⃣ Application

Создаётся на время жизни ServletContext, что означает, что бин существует в пределах всего веб-приложения, а не в пределах одного запроса или сессии.

6️⃣ WebSocket

Живёт в пределах жизненного цикла WebSocket-сессии. Эта область видимости полезна для работы с веб-сокетами в веб-приложениях.

Примеры:

@Component
@Scope("singleton") // Это не обязательно, так как singleton является областью видимости по умолчанию
public class SingletonBean {}

@Component
@Scope("prototype")
public class PrototypeBean {}

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestBean {}

Выбор области видимости бина зависит от требуемого жизненного цикла и видимости объекта в приложении. Singleton подходит для глобальных настроек или кэшированных данных, Prototype — для независимых операций, Request и Session — для данных, специфичных для пользователя в веб-приложениях.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое иерархия интерфейсов Collection Framework ?
Спросят с вероятностью 12%

Java Collection Framework (JCF) — это унифицированная архитектура для представления и манипулирования коллекциями, позволяющая работать с наборами объектов различными способами. Он состоит из нескольких интерфейсов и их реализаций, обеспечивая разработчикам гибкие инструменты для работы с данными.

Основные интерфейсы:

1️⃣Collection: Корневой интерфейс, предоставляющий основные методы для работы с группой объектов, такие как добавление, удаление и проверка размера коллекции. Не реализуется напрямую.

2️⃣List: Представляет упорядоченную коллекцию (также известную как последовательность). Элементы могут быть доступны по индексам, могут содержать дубликаты.
✅ArrayList: Динамический массив.
✅LinkedList: Двусвязный список.
✅Vector: Синхронизированный динамический массив (устаревший).
✅Stack: Расширение класса Vector, реализующее структуру данных стек (LIFO).

3️⃣Set: Коллекция, не содержащая дублирующих элементов.
✅HashSet: Основан на хеш-таблице.
✅LinkedHashSet: Хеш-таблица с сохранением порядка вставки.
✅TreeSet: Основан на красно-чёрном дереве, элементы отсортированы.

4️⃣Queue: Коллекция для хранения элементов перед их обработкой. Элементы удаляются в порядке, определённом политикой очереди.
✅LinkedList: Может также использоваться как очередь.
✅PriorityQueue: Элементы удаляются в соответствии с их приоритетами.

5️⃣Deque: Двусторонняя очередь, позволяющая вставку и удаление с обоих концов.
✅ArrayDeque: Реализация интерфейса Deque, использующая массив.

Интерфейсы для работы с "картами" (не наследуются от Collection):

6️⃣Map: Объект, хранящий пары "ключ-значение". Ключи уникальны.
✅HashMap: Хеш-таблица для хранения пар "ключ-значение".
✅LinkedHashMap: Хеш-таблица с сохранением порядка вставки.
✅TreeMap: Отсортированная карта на основе красно-чёрного дерева.
✅Hashtable: Синхронизированная реализация Map (устаревшая).

Специализированные коллекции:

✅EnumSet и EnumMap: Эффективные реализации интерфейсов Set и Map для использования с перечислениями (enums).

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

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое spring boot и в чём его основное преимущество ?
Спросят с вероятностью 12%

Spring Boot — это проект, целью которого является упрощение процесса создания, конфигурации и развертывания приложений. Это делается за счет предоставления "готовых к использованию" настроек по умолчанию, что позволяет быстро и легко начать работу над новыми проектами.

Основные преимущества:

1️⃣ Быстрый старт: Предлагает ряд стартовых зависимостей (starters), которые автоматически настраивают Spring и связанные с ним компоненты для конкретных сценариев использования, позволяя разработчикам сосредоточиться на бизнес-логике приложения.

2️⃣ Автоконфигурация: Автоматически конфигурирует ваше приложение на основе добавленных в проект библиотек, снижая необходимость в ручной настройке и XML-конфигурациях.

3️⃣ Встроенные сервера приложений: Позволяет легко встраивать серверы приложений, такие как Tomcat, Jetty или Undertow, непосредственно в ваше приложение, упрощая развертывание и тестирование.

4️⃣ Управление зависимостями: Управляет версиями всех зависимостей, гарантируя совместимость и устраняя конфликты.

5️⃣ Продуктивность и независимость: Приложения, созданные с помощью него, могут быть независимыми и самодостаточными, что облегчает их развертывание и запуск.

6️⃣ Простота в развертывании: Приложения могут быть легко упакованы в один исполняемый JAR-файл с включенными всеми необходимыми зависимостями, что делает процесс развертывания простым и удобным.

7️⃣ Актуаторы: Spring Boot предоставляет актуаторы, предоставляющие готовые конечные точки для мониторинга и управления вашим приложением во время его выполнения.

8️⃣ Поддержка разработки: Spring Boot включает в себя инструменты для горячей перезагрузки кода и автоматической перекомпиляции, ускоряя процесс разработки.

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Какую структуру данных реализуем в LinkedList ?
Спросят с вероятностью 12%

LinkedList реализует структуру данных, известную как двусвязный список (doubly linked list). Эта структура состоит из набора узлов, где каждый узел содержит три части: данные (значение элемента) и две ссылки на соседние узлы — предыдущий и следующий. Таким образом, каждый элемент списка имеет ссылку на предыдущий и следующий элементы в списке, что позволяет эффективно выполнять операции вставки и удаления, поскольку не требуется перемещать другие элементы.

Основные особенности:

✅Двунаправленность: Благодаря ссылкам на предыдущий и следующий элементы, обход списка можно осуществлять как в прямом, так и в обратном направлении.
✅Динамический размер: Может динамически изменять свой размер, добавляя или удаляя элементы, без необходимости перевыделения памяти, как в случае с массивами.
✅Эффективное добавление/удаление: Добавление и удаление элементов в любой части списка, особенно в начале или конце, выполняется быстро, поскольку не требует сдвига остальных элементов.
✅Потребление памяти: Каждый элемент списка занимает больше памяти по сравнению с массивами из-за дополнительного хранения ссылок на предыдущий и следующий элементы.

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

Реализует интерфейсы List, Deque и Queue, что делает его очень гибким инструментом. Он может использоваться как список, двусторонняя очередь или как очередь FIFO (First-In-First-Out). Эта гибкость делает эту структуру подходящим для различных сценариев, включая реализацию стеков, очередей, деков и других структур данных.

Пример использования:

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> names = new LinkedList<>();
        
        // Добавление элементов
        names.add("Alice");
        names.addFirst("Bob"); // Добавление в начало списка
        names.addLast("Charlie"); // Добавление в конец списка
        
        // Удаление элементов
        names.removeFirst(); // Удаление первого элемента
        names.removeLast(); // Удаление последнего элемента
        
        // Обход списка
        for (String name : names) {
            System.out.println(name);
        }
    }
}

LinkedList предпочтителен, когда ваши основные операции — это добавление и удаление элементов, особенно если они происходят в начале или конце списка. Однако, если вам часто нужно получать доступ к элементам по индексу, ArrayList может быть более эффективным выбором из-за быстрого произвольного доступа к элементам.

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Какую структуру данных реализуем в LinkedList ?
Спросят с вероятностью 12%

LinkedList реализует структуру данных, известную как двусвязный список (doubly linked list). Эта структура состоит из набора узлов, где каждый узел содержит три части: данные (значение элемента) и две ссылки на соседние узлы — предыдущий и следующий. Таким образом, каждый элемент списка имеет ссылку на предыдущий и следующий элементы в списке, что позволяет эффективно выполнять операции вставки и удаления, поскольку не требуется перемещать другие элементы.

Основные особенности:

✅Двунаправленность: Благодаря ссылкам на предыдущий и следующий элементы, обход списка можно осуществлять как в прямом, так и в обратном направлении.
✅Динамический размер: Может динамически изменять свой размер, добавляя или удаляя элементы, без необходимости перевыделения памяти, как в случае с массивами.
✅Эффективное добавление/удаление: Добавление и удаление элементов в любой части списка, особенно в начале или конце, выполняется быстро, поскольку не требует сдвига остальных элементов.
✅Потребление памяти: Каждый элемент списка занимает больше памяти по сравнению с массивами из-за дополнительного хранения ссылок на предыдущий и следующий элементы.

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

Реализует интерфейсы List, Deque и Queue, что делает его очень гибким инструментом. Он может использоваться как список, двусторонняя очередь или как очередь FIFO (First-In-First-Out). Эта гибкость делает эту структуру подходящим для различных сценариев, включая реализацию стеков, очередей, деков и других структур данных.

Пример использования:

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> names = new LinkedList<>();
        
        // Добавление элементов
        names.add("Alice");
        names.addFirst("Bob"); // Добавление в начало списка
        names.addLast("Charlie"); // Добавление в конец списка
        
        // Удаление элементов
        names.removeFirst(); // Удаление первого элемента
        names.removeLast(); // Удаление последнего элемента
        
        // Обход списка
        for (String name : names) {
            System.out.println(name);
        }
    }
}

LinkedList предпочтителен, когда ваши основные операции — это добавление и удаление элементов, особенно если они происходят в начале или конце списка. Однако, если вам часто нужно получать доступ к элементам по индексу, ArrayList может быть более эффективным выбором из-за быстрого произвольного доступа к элементам.

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое принципы SOLID ?
Спросят с вероятностью 12%

Принципы SOLID — это набор из пяти основополагающих принципов объектно-ориентированного программирования и дизайна, предложенных Робертом Мартином. Эти принципы направлены на улучшение читаемости, поддерживаемости и расширяемости кода, а также на уменьшение его сложности и увеличение гибкости. Этот набор является аббревиатурой, где каждая буква обозначает определённый принцип:

S - Принцип единственной ответственности (Single Responsibility Principle)

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

O - Принцип открытости/закрытости (Open/Closed Principle)

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

L - Принцип подстановки Лисков (Liskov Substitution Principle)

Объекты в программе должны быть заменяемыми на экземпляры их подтипов без изменения правильности выполнения программы. Этот принцип подчёркивает важность совместимости интерфейсов при наследовании и реализации.

I - Принцип разделения интерфейса (Interface Segregation Principle)

Клиенты не должны зависеть от интерфейсов, которые они не используют. Этот принцип предполагает, что лучше иметь много специализированных интерфейсов, чем один "универсальный".

D - Принцип инверсии зависимостей (Dependency Inversion Principle)

Модули высокого уровня не должны зависеть от модулей низкого уровня. Оба типа модулей должны зависеть от абстракций. Кроме того, абстракции не должны зависеть от деталей, а детали — от абстракций. Этот принцип направлен на уменьшение зависимостей между модулями кода.

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое bean, какую роль играет в Spring'е ?
Спросят с вероятностью 12%

Термин "bean" относится к объекту, который управляется контейнером Spring IoC (Inversion of Control). Bean — это фундаментальная концепция, которая позволяет фреймворку автоматически управлять созданием, настройкой и управлением жизненным циклом объектов приложения.

Роль и особенности:

1️⃣Управление жизненным циклом: Создаёт, инициализирует и уничтожает бины. Разработчики могут настроить эти процессы с помощью аннотаций или XML-конфигурации.

2️⃣Внедрение зависимостей (Dependency Injection, DI): Могут автоматически получать свои зависимости от контейнера. Это освобождает разработчиков от необходимости вручную создавать и связывать объекты, делая код более чистым и модульным.

3️⃣Объединение конфигурации: Их конфигурация может быть централизованно определена в конфигурационных файлах XML или с помощью аннотаций в классах. Это упрощает управление конфигурацией приложения.

4️⃣Поддержка аспектно-ориентированного программирования (AOP): Spring бины могут быть легко интегрированы с аспектами для реализации поперечной функциональности, такой как транзакции или логирование.

5️⃣Повторное использование: Контейнер управляет одиночными экземплярами (singleton) бинов по умолчанию, что способствует их повторному использованию и уменьшает потребление ресурсов.

Определение и создание:

Бин можно определить в XML-конфигурации Spring или с помощью аннотаций в классе. Аннотации, такие как @Component, @Service, @Repository, и @Controller, автоматически определяют класс как бин и указывают его роль в приложении.

Пример с аннотацией @Component:

@Component
public class MyService {
    // Класс определён как бин
}

XML-конфигурация для определения бина:

<bean id="myService" class="com.example.MyService"/>

Бины являются центральными элементами приложений на Spring, позволяя фреймворку брать на себя ответственность за многие аспекты управления объектами. Это включает в себя создание объектов, внедрение зависимостей, управление конфигурацией и поддержку аспектно-ориентированного программирования, что в совокупности делает разработку на Spring более эффективной и организованной.

➡️Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Как можно описать абстракцию ?
Спросят с вероятностью 12%

Абстракция — это фундаментальный принцип, заключающийся в выделении важных характеристик некоторого объекта или явления и игнорировании несущественных деталей. Этот принцип позволяет сосредоточиться на том, что объект делает, а не на том, как он это делает, упрощая тем самым проектирование и разработку ПО.

Основные аспекты:

1️⃣ Упрощение: Абстракция помогает упростить сложные реальные ситуации, выделяя основные аспекты и игнорируя менее важные детали. Это позволяет разработчикам создавать более понятные и управляемые модели.

2️⃣ Повторное использование: Абстракция способствует повторному использованию кода, поскольку абстрактные конструкции могут быть реализованы и адаптированы для решения различных задач без изменения основного кода.

3️⃣ Инкапсуляция: Абстракция тесно связана с инкапсуляцией, так как она позволяет скрыть внутреннюю реализацию деталей и предоставить пользователю только необходимый интерфейс для взаимодействия с объектом.

4️⃣ Модульность: Применение абстракции способствует разделению программы на модули, каждый из которых решает свою задачу. Это облегчает понимание, тестирование и поддержку кода.

Примеры:

✅ Абстрактные классы и интерфейсы в объектно-ориентированном программировании (ООП): ООП использует абстрактные классы и интерфейсы для определения и группирования связанных методов без реализации. Конкретные классы затем наследуют абстрактный класс или реализуют интерфейсы, предоставляя специфическую реализацию.

✅ API (Application Programming Interface): API предоставляет абстрактный интерфейс для взаимодействия с программным обеспечением или системой, скрывая сложность реализации и позволяя разработчикам использовать предопределенные функции для достижения своих целей.

✅ Паттерны проектирования: Многие паттерны проектирования, такие как фабрика, стратегия или фасад, основаны на принципах абстракции, позволяя разработчикам создавать гибкие и масштабируемые архитектуры программных систем.

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Чем отличается операция map от flatMap ?
Спросят с вероятностью 19%

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

Операция map

Применяет заданную функцию к каждому элементу коллекции или потока и возвращает новую коллекцию или поток, состоящий из результатов применения этой функции. Важно отметить, что при ее использовании количество элементов во входной и выходной коллекции (или потоке) остается неизменным.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
List<Integer> squaredNumbers = numbers.stream()
.map(n -> n * n)
.collect(Collectors.toList());
// squaredNumbers будет содержать [1, 4, 9, 16]


Операция flatMap

Также применяет заданную функцию к каждому элементу коллекции или потока, но с одним существенным отличием: ожидается, что функция для каждого элемента вернет поток (или коллекцию) элементов, а flatMap "сплющивает" все эти потоки (или коллекции) в один поток. Таким образом, его удобно использовать, когда результатом применения функции является коллекция или поток, и вы хотите получить плоский список всех элементов, а не коллекцию коллекций.
List<List<Integer>> listOfLists = Arrays.asList(
Arrays.asList(1, 2),
Arrays.asList(3, 4, 5)
);
List<Integer> flatList = listOfLists.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList());
// flatList будет содержать [1, 2, 3, 4, 5]

Основные отличия:

✅ Результат: map преобразует каждый элемент коллекции отдельно и возвращает коллекцию того же размера. flatMap может преобразовывать каждый элемент в несколько элементов и "сплющивает" результат в одну коллекцию, что может изменить количество элементов в итоговой коллекции.
✅ Использование: map используется для простых преобразований элементов, а flatMap — для преобразований, при которых каждый элемент может быть представлен несколькими элементами в результате.

Выбор между map и flatMap зависит от конкретной задачи и желаемой структуры выходных данных.

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые

Что такое столп "наследование" ?
Спросят с вероятностью 12%

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

Основные аспекты:

1️⃣ Повторное использование кода: Позволяет новому классу (производному или подклассу) автоматически включать в себя все публичные и защищённые атрибуты и методы базового класса (родительского или суперкласса). Это уменьшает дублирование кода и упрощает его поддержку.

2️⃣ Расширение функциональности: Подклассы могут не только наследовать функциональность родительского класса, но и расширять её, добавляя новые методы и свойства, а также переопределяя существующие.

3️⃣ Полиморфизм: Является основой для полиморфизма — способности методов обрабатывать объекты разных классов, которые имеют общий родительский класс, в единой иерархии классов. Это позволяет использовать один и тот же код для работы с объектами разных типов, что увеличивает гибкость и переиспользуемость кода.

4️⃣ Иерархическая организация: Позволяет строить иерархические структуры классов, что облегчает понимание связей между различными компонентами системы и упрощает моделирование реальных объектов и явлений.

Пример:

// Базовый класс
class Vehicle {
    void move() {
        System.out.println("Транспортное средство движется");
    }
}

// Производный класс
class Car extends Vehicle {
    @Override
    void move() {
        super.move(); // Вызов метода из базового класса
        System.out.println("Автомобиль едет по дороге");
    }
    
    void openDoor() {
        System.out.println("Дверь открыта");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.move(); // Используется переопределённый метод
        myCar.openDoor(); // Используется новый метод
    }
}

В этом примере класс Car наследуется от класса Vehicle, переопределяет его метод move() и добавляет новый метод openDoor(). Это демонстрирует, как наследование позволяет расширять и модифицировать поведение базового класса, а также вводить новую функциональность в производные классы.

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

➡️ Примеры ответов
➡️ Список всех вопросов на Java Developer

🧩 Идущий | 🔐 Собесы | 🔐 Тестовые