docs: add even-only sort strategy task

2026-08-28 21:32:47 +04:00
parent c8c9c05a65
commit 7c8ff139cf
1 changed files with 368 additions and 0 deletions
@@ -0,0 +1,368 @@
 # Техническое задание: `EvenOnlySortStrategy`
 ## Задача
 Создать класс `EvenOnlySortStrategy`, реализующий дополнительное задание по сортировке элементов с чётным значением выбранного числового поля.
 Класс должен использовать **паттерн Стратегия**: он не реализует собственный алгоритм сортировки, а делегирует сортировку переданной реализации `SortStrategy`.
 ## Контракт
 Класс:
 ```java
 public class EvenOnlySortStrategy<T> implements SortStrategy<T>
 ```
 Должен содержать два конструктора:
 ```java
 public EvenOnlySortStrategy()
 ```
 ```java
 public EvenOnlySortStrategy(SortStrategy<T> sortStrategy)
 ```
 Также реализовать метод:
 ```java
 public void setSortStrategy(SortStrategy<T> sortStrategy)
 ```
 и основной метод интерфейса `SortStrategy`:
 ```java
@Override
 public void sort(
        MyList<T> list,
        Comparator<T> comparator
 )
 ```
 Для определения чётности числового поля использовать:
 ```java
 ToIntFunction<T>
 ```
 Поэтому рекомендуется также передавать функцию получения числового значения через конструктор или отдельный метод настройки.
 Для `Student` в качестве функции использовать:
 ```java
 Student::getRecordBookNumber
 ```
 ## Поведение при отсутствии стратегии
 Если `sortStrategy` не задан:
 ```java
 EvenOnlySortStrategy<Student> strategy =
        new EvenOnlySortStrategy<>();
 ```
 то вызов:
 ```java
 strategy.sort(students, comparator);
 ```
 должен завершаться контролируемой ошибкой.
 Рекомендуется выбрасывать:
 ```java
 IllegalStateException
 ```
 с понятным сообщением о том, что стратегия сортировки не задана.
 Не следует использовать `null` как признак успешного выполнения сортировки.
 ## Поведение `setSortStrategy`
 Метод:
 ```java
 setSortStrategy(SortStrategy<T> sortStrategy)
 ```
 заменяет текущую стратегию.
 После вызова метода последующая сортировка должна выполняться именно переданной стратегией.
 Передача `null` должна приводить к контролируемой ошибке, например:
 ```java
 IllegalArgumentException
 ```
 ## Основная бизнес-логика
 `EvenOnlySortStrategy` **не должен содержать код какого-либо алгоритма сортировки**.
 Запрещено реализовывать внутри класса:
 - Merge Sort;
 - Bubble Sort;
 - Selection Sort;
 - другие алгоритмы сортировки;
 - вызовы стандартных методов сортировки Java.
 Класс отвечает только за:
 1. определение элементов, участвующих в специальной сортировке;
 2. сохранение исходных позиций нечётных элементов;
 3. передачу подходящих элементов переданной `SortStrategy`;
 4. восстановление результата на исходные позиции;
 5. делегирование самого алгоритма сортировки.
 Таким образом:
 ```text
 EvenOnlySortStrategy
        │
        ├── определяет, какие элементы сортировать
        │
        ├── передаёт сортируемые элементы
        │       ↓
        │   SortStrategy
        │       ↓
        │   MergeSortStrategy
        │   QuickSortStrategy
        │   ...
        │
        └── возвращает результат на исходные позиции
 ```
 Один `EvenOnlySortStrategy` должен работать с **любой реализацией `SortStrategy`**.
 ## Рекомендуемый алгоритм
 Рекомендуется использовать следующий подход.
 Исходная коллекция:
 ```text
 [7, 8, 3, 2, 5, 4]
 ```
 При выборе `recordBookNumber`:
 ```text
 нечётные: 7, 3, 5
 чётные:   8, 2, 4
 ```
 1. Пройти исходный `MyList`.
 2. С помощью `ToIntFunction<T>` определить чётность каждого элемента.
 3. Запомнить позиции элементов с чётным значением.
 4. Сформировать отдельный `MyList<T>` только из чётных элементов.
 5. Передать эту коллекцию в `sortStrategy.sort(...)`.
 6. Полученные отсортированные элементы последовательно вернуть на сохранённые позиции.
 7. Элементы с нечётными значениями не изменять.
 Например, переданная стратегия `MergeSortStrategy` сортирует:
 ```text
 [8, 2, 4]
 ```
 в:
 ```text
 [2, 4, 8]
 ```
 После возвращения элементов на исходные позиции:
 ```text
 [7, 2, 3, 4, 5, 8]
 ```
 При этом `EvenOnlySortStrategy` не знает, каким способом были отсортированы `8`, `2`, `4`.
 ## Работа с любой `SortStrategy`
 Должно быть возможно использовать:
 ```java
 EvenOnlySortStrategy<Student> strategy =
        new EvenOnlySortStrategy<>(
                new MergeSortStrategy<>(),
                Student::getRecordBookNumber
        );
 ```
 А также после создания заменить стратегию:
 ```java
 strategy.setSortStrategy(new AnotherSortStrategy<>());
 ```
 После этого специальная сортировка должна использовать новую стратегию без изменения `EvenOnlySortStrategy`.
 ## Требования к `ToIntFunction`
 Функция получения числового значения должна передаваться извне.
 Для `Student`:
 ```java
 Student::getRecordBookNumber
 ```
 Стратегия не должна напрямую обращаться к:
 ```java
 student.getRecordBookNumber()
 ```
 или к другим полям `Student`.
 Это позволяет использовать класс с другими типами объектов и другими числовыми полями.
 ## Требования к коллекциям
 Работать необходимо с:
 ```java
 MyList<T>
 ```
 Использование `ArrayList`, `LinkedList` и других стандартных коллекций для хранения элементов запрещено.
 Вспомогательная коллекция чётных элементов также должна быть `MyList<T>`.
 ## Тесты
 ### Переданная стратегия используется
 Передать `MergeSortStrategy`.
 Проверить, что сортировка чётных элементов выполняется переданной стратегией.
 ### Замена стратегии
 1. Создать `EvenOnlySortStrategy` с одной реализацией `SortStrategy`.
 2. Выполнить сортировку.
 3. Вызвать `setSortStrategy(...)`.
 4. Выполнить сортировку повторно.
 5. Проверить, что используется новая стратегия.
 ### Конструктор без стратегии
 Создать:
 ```java
 new EvenOnlySortStrategy<>();
 ```
 Вызвать `sort()`.
 Проверить выброс `IllegalStateException`.
 ### Конструктор со стратегией
 Создать объект с `MergeSortStrategy`.
 Проверить успешное выполнение сортировки.
 ### Передача `null` в `setSortStrategy`
 Проверить выброс `IllegalArgumentException`.
 ### Все элементы нечётные
 ```text
 [7, 3, 5, 1]
 ```
 Результат должен полностью совпадать с исходной коллекцией.
 ### Все элементы чётные
 ```text
 [8, 2, 6, 4]
 ```
 Ожидаемый результат:
 ```text
 [2, 4, 6, 8]
 ```
 ### Смешанные значения
 ```text
 [7, 8, 3, 2, 5, 4]
 ```
 Ожидаемый результат:
 ```text
 [7, 2, 3, 4, 5, 8]
 ```
 ### Повторяющиеся значения
 Проверить корректность сортировки при наличии одинаковых чётных значений.
 ### Один элемент
 Проверить отдельно чётный и нечётный элемент.
 ### Пустая коллекция
 Сортировка не должна приводить к ошибке.
 ### Проверка сохранения нечётных элементов
 Проверить не только значения, но и то, что объекты с нечётным `recordBookNumber` остались на тех же индексах.
 ### Проверка разных реализаций
 Использовать `EvenOnlySortStrategy` с каждой доступной реализацией `SortStrategy`.
 Проверить, что результат специальной сортировки соответствует контракту независимо от конкретного алгоритма.
 ### Проверка делегирования
 Создать тестовую реализацию `SortStrategy`, которая фиксирует факт вызова `sort()`.
 Передать её в `EvenOnlySortStrategy`.
 Проверить, что:
 - `sort()` был вызван;
 - в стратегию передана коллекция только с чётными элементами;
 - сама `EvenOnlySortStrategy` не выполняет сортировку самостоятельно.
 ## Результат
 Реализовать:
 ```text
 EvenOnlySortStrategy.java
 ```
 Класс должен зависеть от абстракции:
 ```text
 SortStrategy<T>
 MyList<T>
 Comparator<T>
 ToIntFunction<T>
 ```
 и **не должен содержать реализации конкретного алгоритма сортировки**.
 ## Git
 Ветка:
 ```text
 feature/even-only-sort-strategy
 ```