🤔 Какая коллекция реализует дисциплину обслуживания FIFO?

FIFO (First-In, First-Out) – это принцип обработки данных: "первым вошёл – первым вышел".

🟠Коллекции, реализующие FIFO
Пример работы FIFO с Queue

import java.util.*;

public class FifoExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>(); // Можно заменить на ArrayDeque

        queue.add("Первый");
        queue.add("Второй");
        queue.add("Третий");

        System.out.println(queue.poll()); // Первый
        System.out.println(queue.poll()); // Второй
        System.out.println(queue.poll()); // Третий
    }
}

🟠Разница `poll()`, `remove()` и `peek()`

Queue<Integer> queue = new LinkedList<>();
queue.add(10);
System.out.println(queue.peek());  // 10 (но не удаляет)
System.out.println(queue.poll());  // 10 (удаляет)
System.out.println(queue.poll());  // null (очередь пуста)

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

🤔 Какие способы синхронизации в Java есть?

Синхронизация реализуется через synchronized, Lock, ReentrantLock, volatile, Atomic-классы, а также через высокоуровневые конструкции, такие как CountDownLatch, Semaphore, ExecutorService.

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

🤔 Используешь в работе Lambda-выражения?

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

🟠Итерация по коллекциям
Использование лямбда-выражений с методом forEach позволяет компактно и удобно итерировать по элементам коллекций.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

🟠Фильтрация и преобразование коллекций
С использованием Stream API и лямбда-выражений можно легко фильтровать, сортировать и преобразовывать коллекции.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList());

filteredNames.forEach(System.out::println); // Вывод: Alice

🟠Сортировка коллекций
Лямбда-выражения упрощают сортировку коллекций с использованием метода sort.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.sort((name1, name2) -> name1.compareTo(name2));
names.forEach(System.out::println);

🟠Использование функциональных интерфейсов
Лямбда-выражения широко используются с функциональными интерфейсами, такими как Predicate, Function, Consumer и Supplier.

// Predicate
Predicate<String> startsWithA = s -> s.startsWith("A");
boolean result = startsWithA.test("Alice"); // true

// Function
Function<String, Integer> lengthFunction = s -> s.length();
int length = lengthFunction.apply("Hello"); // 5

// Consumer
Consumer<String> printConsumer = s -> System.out.println(s);
printConsumer.accept("Hello, World!"); // Вывод: Hello, World!

// Supplier
Supplier<String> stringSupplier = () -> "Hello, Supplier!";
String suppliedString = stringSupplier.get();
System.out.println(suppliedString); // Вывод: Hello, Supplier!

🟠Параллельные вычисления
Лямбда-выражения с использованием параллельных потоков позволяют легко выполнять параллельные вычисления.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream()
    .mapToInt(Integer::intValue)
    .sum();

System.out.println("Sum: " + sum); // Вывод: Sum: 15

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

Предположим, у нас есть список сотрудников, и мы хотим отфильтровать и отсортировать их по имени.

import java.util.*;
import java.util.stream.Collectors;

class Employee {
    private String name;
    private int age;

    public Employee(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 "Employee{name='" + name + "', age=" + age + '}';
    }
}

public class LambdaExample {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", 30),
            new Employee("Bob", 25),
            new Employee("Charlie", 35),
            new Employee("David", 28)
        );

        // Фильтрация и сортировка сотрудников по имени
        List<Employee> filteredAndSorted = employees.stream()
            .filter(e -> e.getAge() > 27)
            .sorted(Comparator.comparing(Employee::getName))
            .collect(Collectors.toList());

        filteredAndSorted.forEach(System.out::println);
    }
}

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

🤔 Как организовать поиск по ArrayList?

Поиск может быть двух типов:
- линейный — с помощью contains, indexOf, когда список не отсортирован (сложность O(n)).
- бинарный — с помощью Collections.binarySearch, если список отсортирован (сложность O(log n)), но в этом случае предварительно надо отсортировать коллекцию.

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

🤔 Какие Fetching Types знаешь в Hibernate и чем они отличаются?

В Hibernate существует два типа загрузки (Fetching Types) данных:
Lazy (ленивая загрузка)
Eager (жадная загрузка)
Эти типы определяют, как Hibernate загружает связанные сущности при выполнении запроса.

🚩Lazy Fetching (ленивая загрузка)

Данные загружаются только при первом обращении к ним.
Экономит память и ресурсы, так как ненужные данные не загружаются сразу.
Используется по умолчанию в @OneToMany, @ManyToMany.

@Entity
class User {
    @Id @GeneratedValue
    private Long id;
    
    private String name;

    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Order> orders;  // Загрузятся ТОЛЬКО при первом вызове getOrders()
}

User user = session.get(User.class, 1L);  // Загружается только User
List<Order> orders = user.getOrders();   // Запрос в БД выполняется ТОЛЬКО здесь

🚩Eager Fetching (жадная загрузка)

Hibernate загружает все связанные данные сразу, даже если они не нужны.
Увеличивает время выполнения запроса, так как делает JOIN или несколько отдельных запросов.
Используется по умолчанию в @ManyToOne, @OneToOne.

@Entity
class User {
    @Id @GeneratedValue
    private Long id;
    
    private String name;

    @OneToMany(mappedBy = "user", fetch = FetchType.EAGER)
    private List<Order> orders;  // Загружается сразу при получении User
}

User user = session.get(User.class, 1L);  // Загружается User + сразу все его Orders

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

🤔 Что лежит в основе каждого исключения?

Все исключения происходят от базового класса Throwable. Существует два основных подвида: Exception и Error. Первые представляют ошибки, которые можно обработать в коде (например, проблемы с вводом-выводом), вторые связаны с критическими сбоями виртуальной машины. Исключения делятся также на проверяемые (которые обязательно нужно либо обработать, либо явно объявить) и непроверяемые (возникающие в процессе выполнения и не требующие обязательной обработки).

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

🤔 В чём заключается разница между методами start() и run()?

🚩`start()` – создаёт новый поток

Метод start() создаёт новый поток и вызывает run() внутри него.

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Работает поток: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Запускаем новый поток

        System.out.println("Работает поток: " + Thread.currentThread().getName());
    }
}

Вывод (разные потоки работают параллельно)

Работает поток: main
Работает поток: Thread-0

🚩`run()` – выполняется в ТЕКУЩЕМ потоке (без создания нового)

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

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.run(); // ❌ Ошибка! Работает в главном потоке

        System.out.println("Работает поток: " + Thread.currentThread().getName());
    }
}

Вывод (run() работает в главном потоке, а не в новом)

Работает поток: main
Работает поток: main

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

🤔 Докажи CAP теорему?

В распределённой системе нельзя одновременно достичь:
- Consistency (согласованность),
- Availability (доступность),
- Partition Tolerance (устойчивость к сетевым разделениям).
Можно выбрать только 2 из 3 — это доказано в теореме Эрика Брюера.

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

🤔 Какие виды тестов знаешь?

В программировании существует множество видов тестирования, которые можно разделить на категории по уровню тестирования, методам выполнения и целям. Вот основные виды:

🚩По уровню тестирования

🟠Модульное тестирование (Unit Testing)
Тестирование отдельных методов или классов.
Цель: Проверить работу минимальных компонентов программы.
Инструменты: JUnit, TestNG.

  @Test
  public void testAddition() {
      assertEquals(5, Calculator.add(2, 3));
  }
  

🟠Интеграционное тестирование (Integration Testing)
Тестирование взаимодействия между модулями.
Цель: Убедиться, что модули правильно работают вместе.
Пример: Проверка взаимодействия сервиса и базы данных.
Инструменты: Spring Test, Apache Camel Test.

🟠Системное тестирование (System Testing)
Проверка всей системы как единого целого.
Цель: Убедиться, что все компоненты работают вместе и система соответствует требованиям.

🟠Приемочное тестирование (Acceptance Testing)
Проводится с участием клиента или конечных пользователей.
Цель: Убедиться, что система удовлетворяет бизнес-требованиям.

🚩По методам выполнения

🟠Ручное тестирование (Manual Testing)
Тесты выполняются вручную.
Цель: Найти ошибки, которые может не уловить автоматизация.
Пример: Тестировщик вручную проверяет пользовательский интерфейс.

🟠Автоматизированное тестирование (Automated Testing)
Тесты выполняются автоматически с использованием скриптов и инструментов.
Цель: Снизить время и затраты на повторяющиеся тесты.
Инструменты: Selenium, JUnit, Appium.

🚩По целям тестирования

🟠Функциональное тестирование
Проверяет, что функции системы работают как ожидалось.
Цель: Убедиться в соответствии требованиям.
Инструменты: Selenium, Postman.

🟠Нефункциональное тестирование
Тестирование производительности (Performance Testing): Проверяет скорость, отклик и стабильность.
Инструменты: JMeter, Gatling.
Тестирование безопасности (Security Testing): Проверяет защиту системы.
Инструменты: OWASP ZAP, Burp Suite.
Тестирование удобства использования (Usability Testing): Проверяет интерфейс на удобство для пользователя.

🚩По типам тестирования

🟠Smoke Testing
Быстрая проверка работоспособности ключевых функций.
Цель: Убедиться, что основные функции работают, прежде чем углубляться в тесты.

🟠Регрессионное тестирование
Проверяет, что новые изменения не сломали старую функциональность.
Цель: Убедиться, что баги, исправленные ранее, не повторились.

🟠Тестирование черного ящика (Black Box Testing)
Проверяет систему без знаний о внутреннем устройстве.
Цель: Оценить функциональность с точки зрения пользователя.

🟠Тестирование белого ящика (White Box Testing)
Проверяет систему с учетом внутренней структуры кода.
Цель: Оценить корректность логики программы.

🚩Специальные виды тестирования

🟠A/B тестирование
Проверяет, какая версия системы лучше (например, два варианта интерфейса).
Цель: Повысить пользовательский опыт.

🟠Тестирование нагрузки (Load Testing)
Проверяет, как система работает под большой нагрузкой.
Инструменты: Apache JMeter.

🟠Тестирование на отказоустойчивость (Stress Testing)
Проверяет, как система работает в условиях сверхвысокой нагрузки.

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

🤔 Какой оператор позволяет принудительно выбросить исключение?

Оператор throw используется для генерации исключения вручную во время выполнения.

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

🤔 Как устроена память 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();
}

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

🤔 Для чего используются атрибуты сервлетов и как происходит работа с ними?

1. Атрибуты позволяют передавать данные между сервлетами и другими компонентами в приложении.
2. Они сохраняются в объектах HttpServletRequest, HttpSession, ServletContext.
3. Методы: setAttribute(), getAttribute(), removeAttribute() используются для работы с атрибутами.

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

🤔 Расскажи про способы оптимизации запросов в БД

Оптимизация запросов в базе данных (БД) — это процесс улучшения их производительности, чтобы они выполнялись быстрее и использовали меньше ресурсов. Рассмотрим основные способы оптимизации SQL-запросов.

🟠Индексы
Индексы ускоряют поиск данных, создавая структуру, похожую на оглавление книги. Вместо полного перебора таблицы (Full Table Scan), БД быстро находит нужные строки по индексу.

CREATE INDEX idx_user_name ON users(name);

🟠Оптимизация `SELECT`
Избегайте SELECT *, так как это нагружает систему избыточными данными.
Плохо

SELECT * FROM users;

Хорошо

SELECT id, name FROM users;

🟠Использование `EXPLAIN`
Перед оптимизацией полезно посмотреть, как БД выполняет запрос.

EXPLAIN SELECT * FROM users WHERE name = 'Ivan';

🟠Ограничение выборки (`LIMIT`, `OFFSET`)
Если вам нужно получить только первые N строк, используйте LIMIT, чтобы БД не грузила лишние данные.

SELECT * FROM users ORDER BY id LIMIT 10;

🟠Оптимизация `JOIN`
Соединение (JOIN) таблиц может быть дорогостоящим. Вот несколько рекомендаций:
- Используйте индексы на полях, участвующих в JOIN.
- Если возможно, замените сложные JOIN на подзапросы (EXISTS, IN).

CREATE INDEX idx_orders_user_id ON orders(user_id);

🟠Кеширование запросов
Часто повторяющиеся запросы можно кэшировать на уровне БД (QUERY CACHE в MySQL) или в приложении (Redis, Memcached).

SET GLOBAL query_cache_size = 1000000;

🟠Нормализация и денормализация
Нормализация уменьшает дублирование данных, разбивая таблицы.
Денормализация может ускорить работу, дублируя данные и уменьшая количество JOIN.

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

🤔 В чем разница между interrupted() и isInterrupted()?

- interrupted() — статический метод, проверяет и сбрасывает флаг прерывания текущего потока;
- isInterrupted() — экземплярный метод, проверяет, не сбрасывая флаг прерывания для данного потока.

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

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

Ограничения (constraints) – это правила, которые ограничивают возможные значения данных или ограничивают поведение системы.

🟠Ограничения в базах данных (SQL Constraints)
В SQL ограничения гарантируют корректность данных в таблицах.

CREATE TABLE Users (
    id INT PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    age INT CHECK (age > 0),
    country VARCHAR(50) DEFAULT 'Unknown'
);

🟠Ограничения в Java Generics (`<T extends ...>`)
Ограничения в Generics позволяют задавать допустимые типы.

class Box<T> {
    T value;
    public Box(T value) { this.value = value; }
}
Box<String> strBox = new Box<>("Hello");
Box<Integer> intBox = new Box<>(10);

class NumberBox<T extends Number> { // Ограничение: T должно быть числом
    T value;
    public NumberBox(T value) { this.value = value; }

    public double square() {
        return value.doubleValue() * value.doubleValue();
    }
}

🟠Ограничения в потоках (synchronized, volatile, join)
В многопоточности ограничения помогают избежать гонок потоков.

class Counter {
    private int count = 0;

    public synchronized void increment() { // Только один поток может изменять count одновременно
        count++;
    }
}

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

🤔 Для чего в стримах предназначены методы flatMap(), flatMapToInt(), flatMapToDouble(), flatMapToLong()?

Используются для распаковки вложенных стримов:
- flatMap() превращает каждый элемент в стрим, затем объединяет их;
- позволяет работать с вложенными коллекциями (например, список списков) как с единым потоком.

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

🤔 Что такое heap, stack?

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

🚩Heap (Куча)

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

🟠Особенности
Куча разделена на поколения: молодое поколение (Young Generation) и старое поколение (Old Generation).
Молодое поколение включает в себя области Eden Space и Survivor Spaces (S0 и S1).
Старое поколение хранит долгоживущие объекты.

🟠Управление памятью
Куча управляется сборщиком мусора (Garbage Collector), который автоматически освобождает память, занятую объектами, которые больше не используются.

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

public class Example {
    public static void main(String[] args) {
        Example obj = new Example(); // obj создается в куче
    }
}

🚩Stack (Стек)

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

🟠Особенности
Каждый поток имеет свой собственный стек.
Стек хранит кадры (frames) для каждого вызова метода. Каждый кадр содержит локальные переменные метода и информацию о вызовах.

🟠Управление памятью
Память в стеке автоматически управляется при вызове методов и выходе из них. Когда метод вызывается, создается новый кадр в стеке; когда метод завершает выполнение, его кадр удаляется из стека.

🟠Использование
Стек используется для хранения примитивных типов данных и ссылок на объекты, которые находятся в куче.
Локальные переменные методов и параметры методов хранятся в стеке.

public class Example {
    public static void main(String[] args) {
        int localVar = 10; // localVar хранится в стеке
        Example obj = new Example(); // Ссылка на obj хранится в стеке, а сам объект — в куче
        obj.method();
    }

    public void method() {
        int anotherVar = 20; // anotherVar хранится в стеке
    }
}

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

🤔 Приведи примеры порождающих шаблонов проектирования.

- Singleton — единственный экземпляр класса;
- Factory Method — создание объектов через фабричный метод;
- Abstract Factory — создание семейства связанных объектов;
- Builder — пошаговое создание сложного объекта;
- Prototype — создание копий существующих объектов.

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

🤔 В чём различие между LeftJoin , RightJoin и InnerJoin?

LEFT JOIN, RIGHT JOIN и INNER JOIN являются операциями соединения таблиц, каждая из которых используется для объединения строк из двух или более таблиц на основе связанных столбцов между ними. Различие между этими типами соединений заключается в том, какие строки выбираются для включения в результаты запроса.

🚩INNER JOIN

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

🚩LEFT JOIN (или LEFT OUTER JOIN)

Возвращает все строки из левой таблицы (ТаблицаA), а также соответствующие строки из правой таблицы (ТаблицаB). Если совпадение в правой таблице не найдено, результат будет содержать NULL на месте столбцов правой таблицы.

🚩RIGHT JOIN (или RIGHT OUTER JOIN)

Работает аналогично LEFT JOIN, но возвращает все строки из правой таблицы (ТаблицаB), а также соответствующие строки из левой таблицы (ТаблицаA). Если совпадение в левой таблице не найдено, результат будет содержать NULL на месте столбцов левой таблицы.

INNER JOIN используется для получения строк с совпадениями в обеих таблицах.
LEFT JOIN возвращает все строки из левой таблицы и соответствующие строки из правой таблицы; если соответствий нет, вместо столбцов правой таблицы будут NULL.
RIGHT JOIN возвращает все строки из правой таблицы и соответствующие строки из левой таблицы; если соответствий нет, вместо столбцов левой таблицы будут NULL.

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

🤔 Что такое SLA?

SLA (Service Level Agreement) — это соглашение об уровне сервиса между поставщиком и клиентом.
Описывает:
- доступность (например, 99.9%);
- время отклика;
- действия в случае сбоя;
- метрики качества сервиса.

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

🤔 Обеспечит ли Stream API RandomAcess?

Нет, Stream API не поддерживает RandomAccess, потому что он работает с потоком данных, а не с индексированными структурами.

🚩Почему Stream API не поддерживает `RandomAccess`?

🟠Stream – это поток данных
который не обязательно хранится в памяти в виде структуры, поддерживающей случайный доступ.
🟠Нет индексов
в отличие от List, Stream не позволяет получить элемент по индексу (get(index) отсутствует).
🟠Обход последовательный
элементы проходятся один за другим, что делает случайный доступ невозможным.

List (с RandomAccess)

List<Integer> list = new ArrayList<>(List.of(1, 2, 3, 4, 5));
System.out.println(list.get(2)); // Быстрое получение элемента по индексу

Stream (без RandomAccess)

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
stream.skip(2).findFirst().ifPresent(System.out::println); // Ищем 3-й элемент

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