diff --git a/app/src/main/java/ru/project/sorting/BubbleSortStrategy.java b/app/src/main/java/ru/project/sorting/BubbleSortStrategy.java
new file mode 100644
index 0000000..38172db
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/BubbleSortStrategy.java
@@ -0,0 +1,24 @@
+package ru.project.sorting;
+
+import ru.project.list.MyList;
+import java.util.Comparator;
+
+public class BubbleSortStrategy<T> implements SortStrategy<T> {
+
+    @Override
+    public void sort(MyList<T> list, Comparator<T> comparator) {
+        if (list == null || list.size() <= 1) {
+            return;
+        }
+        int n = list.size();
+        for (int i = 0; i < n - 1; i++) {
+            for (int j = 0; j < n - i - 1; j++) {
+                if (comparator.compare(list.get(j), list.get(j + 1)) > 0) {
+                    T temp = list.get(j);
+                    list.set(j, list.get(j + 1));
+                    list.set(j + 1, temp);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java b/app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java
new file mode 100644
index 0000000..dea539e
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java
@@ -0,0 +1,84 @@
+package ru.project.sorting;
+
+import ru.project.list.MyList;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.ToIntFunction;
+
+public class EvenOnlyMergeSortStrategy<T> implements SortStrategy<T> {
+
+    private final ToIntFunction<T> valueExtractor;
+
+    public EvenOnlyMergeSortStrategy(ToIntFunction<T> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public void sort(MyList<T> list, Comparator<T> comparator) {
+        if (list == null || list.size() <= 1) {
+            return;
+        }
+
+        List<Integer> evenIndices = new ArrayList<>();
+        List<T> evenElements = new ArrayList<>();
+
+        for (int i = 0; i < list.size(); i++) {
+            T element = list.get(i);
+            int value = valueExtractor.applyAsInt(element);
+            if (value % 2 == 0) {
+                evenIndices.add(i);
+                evenElements.add(element);
+            }
+        }
+
+        if (evenElements.size() <= 1) {
+            return;
+        }
+
+        List<T> sortedEven = mergeSort(evenElements, comparator);
+
+        for (int j = 0; j < evenIndices.size(); j++) {
+            list.set(evenIndices.get(j), sortedEven.get(j));
+        }
+    }
+
+    private List<T> mergeSort(List<T> list, Comparator<T> comparator) {
+        if (list.size() <= 1) {
+            return list;
+        }
+
+        int mid = list.size() / 2;
+        List<T> left = mergeSort(list.subList(0, mid), comparator);
+        List<T> right = mergeSort(list.subList(mid, list.size()), comparator);
+
+        return merge(left, right, comparator);
+    }
+
+    private List<T> merge(List<T> left, List<T> right, Comparator<T> comparator) {
+        List<T> result = new ArrayList<>();
+        int i = 0, j = 0;
+
+        while (i < left.size() && j < right.size()) {
+            if (comparator.compare(left.get(i), right.get(j)) <= 0) {
+                result.add(left.get(i));
+                i++;
+            } else {
+                result.add(right.get(j));
+                j++;
+            }
+        }
+
+        while (i < left.size()) {
+            result.add(left.get(i));
+            i++;
+        }
+
+        while (j < right.size()) {
+            result.add(right.get(j));
+            j++;
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java b/app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java
new file mode 100644
index 0000000..32349c1
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java
@@ -0,0 +1,94 @@
+package ru.project.sorting;
+
+import ru.project.collection.MyLinkedList;
+import ru.project.collection.MyList;
+
+import java.util.Comparator;
+import java.util.function.ToIntFunction;
+
+public class EvenOnlySortStrategy<T> implements SortStrategy<T> {
+
+    private SortStrategy<T> sortStrategy;
+    private ToIntFunction<T> valueExtractor;
+
+    public EvenOnlySortStrategy() {
+    }
+
+    public EvenOnlySortStrategy(SortStrategy<T> sortStrategy) {
+        setSortStrategy(sortStrategy);
+    }
+
+    public EvenOnlySortStrategy(
+            SortStrategy<T> sortStrategy,
+            ToIntFunction<T> valueExtractor
+    ) {
+        setSortStrategy(sortStrategy);
+        setValueExtractor(valueExtractor);
+    }
+
+    public void setSortStrategy(SortStrategy<T> sortStrategy) {
+        if (sortStrategy == null) {
+            throw new IllegalArgumentException("Sort strategy must not be null");
+        }
+
+        this.sortStrategy = sortStrategy;
+    }
+
+    public void setValueExtractor(ToIntFunction<T> valueExtractor) {
+        if (valueExtractor == null) {
+            throw new IllegalArgumentException("Value extractor must not be null");
+        }
+
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public void sort(MyList<T> list, Comparator<T> comparator) {
+        if (sortStrategy == null) {
+            throw new IllegalStateException("Sort strategy is not set");
+        }
+
+        if (valueExtractor == null) {
+            throw new IllegalStateException("Value extractor is not set");
+        }
+
+        if (list == null || list.size() <= 1) {
+            return;
+        }
+
+        int evenCount = 0;
+
+        for (int i = 0; i < list.size(); i++) {
+            T element = list.get(i);
+
+            if (valueExtractor.applyAsInt(element) % 2 == 0) {
+                evenCount++;
+            }
+        }
+
+        if (evenCount <= 1) {
+            return;
+        }
+
+        MyList<T> evenElements = new MyLinkedList<>();
+        int[] evenIndexes = new int[evenCount];
+
+        int evenIndex = 0;
+
+        for (int i = 0; i < list.size(); i++) {
+            T element = list.get(i);
+
+            if (valueExtractor.applyAsInt(element) % 2 == 0) {
+                evenElements.add(element);
+                evenIndexes[evenIndex] = i;
+                evenIndex++;
+            }
+        }
+
+        sortStrategy.sort(evenElements, comparator);
+
+        for (int i = 0; i < evenIndexes.length; i++) {
+            list.set(evenIndexes[i], evenElements.get(i));
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/ru/project/sorting/MergeSortStrategy.java b/app/src/main/java/ru/project/sorting/MergeSortStrategy.java
new file mode 100644
index 0000000..598f754
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/MergeSortStrategy.java
@@ -0,0 +1,67 @@
+package ru.project.sorting;
+
+import ru.project.collection.MyList;
+
+import java.util.Comparator;
+
+public class MergeSortStrategy<T> implements SortStrategy<T> {
+
+    @Override
+    public void sort(MyList<T> list, Comparator<T> comparator) {
+        if (list == null || list.size() <= 1) {
+            return;
+        }
+        mergeSort(list, 0, list.size() - 1, comparator);
+    }
+
+    private void mergeSort(MyList<T> list, int left, int right, Comparator<T> comparator) {
+        if (left >= right) {
+            return;
+        }
+        int mid = (left + right) / 2;
+        mergeSort(list, left, mid, comparator);
+        mergeSort(list, mid + 1, right, comparator);
+        merge(list, left, mid, right, comparator);
+    }
+
+    private void merge(MyList<T> list, int left, int mid, int right, Comparator<T> comparator) {
+        int leftSize = mid - left + 1;
+        int rightSize = right - mid;
+
+        @SuppressWarnings("unchecked")
+        T[] leftArray = (T[]) new Object[leftSize];
+        @SuppressWarnings("unchecked")
+        T[] rightArray = (T[]) new Object[rightSize];
+
+        for (int i = 0; i < leftSize; i++) {
+            leftArray[i] = list.get(left + i);
+        }
+        for (int j = 0; j < rightSize; j++) {
+            rightArray[j] = list.get(mid + 1 + j);
+        }
+
+        int i = 0, j = 0, k = left;
+
+        while (i < leftSize && j < rightSize) {
+            if (comparator.compare(leftArray[i], rightArray[j]) <= 0) {
+                list.set(k, leftArray[i]);
+                i++;
+            } else {
+                list.set(k, rightArray[j]);
+                j++;
+            }
+            k++;
+        }
+
+        while (i < leftSize) {
+            list.set(k, leftArray[i]);
+            i++;
+            k++;
+        }
+        while (j < rightSize) {
+            list.set(k, rightArray[j]);
+            j++;
+            k++;
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/ru/project/sorting/SortStrategy.java b/app/src/main/java/ru/project/sorting/SortStrategy.java
new file mode 100644
index 0000000..059d908
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/SortStrategy.java
@@ -0,0 +1,9 @@
+package ru.project.sorting;
+
+import ru.project.collection.MyList;
+
+import java.util.Comparator;
+
+public interface SortStrategy<T> {
+    void sort(MyList<T> list, Comparator<T> comparator);
+}
\ No newline at end of file
diff --git a/app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java b/app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java
new file mode 100644
index 0000000..fea72f6
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java
@@ -0,0 +1,12 @@
+package ru.project.sorting;
+
+import ru.project.student.Student;
+import java.util.Comparator;
+
+public class StudentAverageGradeComparator implements Comparator<Student> {
+
+    @Override
+    public int compare(Student s1, Student s2) {
+        return Double.compare(s1.getAverageGrade(), s2.getAverageGrade());
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/ru/project/sorting/StudentGroupComparator.java b/app/src/main/java/ru/project/sorting/StudentGroupComparator.java
new file mode 100644
index 0000000..75cae82
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/StudentGroupComparator.java
@@ -0,0 +1,12 @@
+package ru.project.sorting;
+
+import ru.project.student.Student;
+import java.util.Comparator;
+
+public class StudentGroupComparator implements Comparator<Student> {
+
+    @Override
+    public int compare(Student s1, Student s2) {
+        return s1.getGroupNumber().compareTo(s2.getGroupNumber());
+    }
+}
diff --git a/app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java b/app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java
new file mode 100644
index 0000000..0e4a714
--- /dev/null
+++ b/app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java
@@ -0,0 +1,12 @@
+package ru.project.sorting;
+
+import ru.project.student.Student;
+import java.util.Comparator;
+
+public class StudentRecordBookComparator implements Comparator<Student> {
+
+    @Override
+    public int compare(Student s1, Student s2) {
+        return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/ru/project/student/Student.java b/app/src/main/java/ru/project/student/Student.java
index 3e716a7..f4cd7fc 100644
--- a/app/src/main/java/ru/project/student/Student.java
+++ b/app/src/main/java/ru/project/student/Student.java
@@ -3,21 +3,32 @@ package ru.project.student;
 import java.util.Objects;
 
 public class Student {
+
+  public static final double MIN_AVERAGE_GRADE = 0.0;
+  public static final double MAX_AVERAGE_GRADE = 5.0;
+  public static final int MIN_RECORD_BOOK_NUMBER = 1;
+  public static final String GROUP_NUMBER_PATTERN = "^[A-Z][0-9]{2}$";
+
   private final String groupNumber;
   private final double averageGrade;
   private final int recordBookNumber;
 
   public Student(String groupNumber, double averageGrade, int recordBookNumber) {
-    if (groupNumber == null || !groupNumber.matches("^[A-Z][0-9]{2}$")) {
+    if (groupNumber == null || !groupNumber.matches(GROUP_NUMBER_PATTERN)) {
       throw new IllegalArgumentException(
-          "Group number must match format: one uppercase letter + two digits (e.g. A12)");
+          "Group number must match pattern: " + GROUP_NUMBER_PATTERN);
     }
-    if (averageGrade < 0.0 || averageGrade > 5.0) {
-      throw new IllegalArgumentException("Average grade must be between 0.0 and 5.0");
+    if (averageGrade < MIN_AVERAGE_GRADE || averageGrade > MAX_AVERAGE_GRADE) {
+      throw new IllegalArgumentException(
+          "Average grade must be between " + MIN_AVERAGE_GRADE + " and " + MAX_AVERAGE_GRADE);
     }
     if (recordBookNumber <= 0) {
       throw new IllegalArgumentException("Record book number must be positive");
     }
+    if (recordBookNumber < MIN_RECORD_BOOK_NUMBER) {
+      throw new IllegalArgumentException(
+          "Record book number must be at least " + MIN_RECORD_BOOK_NUMBER);
+    }
     this.groupNumber = groupNumber;
     this.averageGrade = averageGrade;
     this.recordBookNumber = recordBookNumber;
@@ -27,6 +38,10 @@ public class Student {
     return groupNumber;
   }
 
+  public double getAverageGrade() {
+    return averageGrade;
+  }
+
   public int getRecordBookNumber() {
     return recordBookNumber;
   }
@@ -39,11 +54,22 @@ public class Student {
     return new Student(this.groupNumber, averageGrade, this.recordBookNumber);
   }
 
-  public Student withRecordBookNumber(int recordBookNumber) {
-    return new Student(this.groupNumber, this.averageGrade, recordBookNumber);
+  public static double getMinAverageGrade() {
+    return MIN_AVERAGE_GRADE;
+  }
+
+  public static double getMaxAverageGrade() {
+    return MAX_AVERAGE_GRADE;
+  }
+
+  public static int getMinRecordBookNumber() {
+    return MIN_RECORD_BOOK_NUMBER;
+  }
+
+  public static String getGroupNumberPattern() {
+    return GROUP_NUMBER_PATTERN;
   }
 
-  @Override
   public String toString() {
     return "Student{"
         + "groupNumber='"
@@ -56,16 +82,19 @@ public class Student {
         + '}';
   }
 
+  @Override
+  public int hashCode() {
+    return Objects.hash(groupNumber, averageGrade, recordBookNumber);
+  }
+
   @Override
   public boolean equals(Object obj) {
     if (this == obj) {
       return true;
     }
-
     if (obj == null || getClass() != obj.getClass()) {
       return false;
     }
-
     if (this.hashCode() != obj.hashCode()) {
       return false;
     }
@@ -75,25 +104,4 @@ public class Student {
         && recordBookNumber == student.recordBookNumber
         && Objects.equals(groupNumber, student.groupNumber);
   }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(groupNumber, averageGrade, recordBookNumber);
-  }
-
-  public static double getMinAverageGrade() {
-    return 0.0;
-  }
-
-  public static double getMaxAverageGrade() {
-    return 5.0;
-  }
-
-  public static int getMinRecordBookNumber() {
-    return 1;
-  }
-
-  public static String getGroupNumberPattern() {
-    return "^[A-Z][0-9]{2}$";
-  }
 }
diff --git a/app/src/test/java/ru/project/Sorting/SortStrategyTest.java b/app/src/test/java/ru/project/Sorting/SortStrategyTest.java
new file mode 100644
index 0000000..6e0472c
--- /dev/null
+++ b/app/src/test/java/ru/project/Sorting/SortStrategyTest.java
@@ -0,0 +1,163 @@
+package ru.project.sorting;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import ru.project.list.MyList;
+import ru.project.list.MyLinkedList;
+import ru.project.student.Student;
+
+import java.util.Comparator;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SortStrategyTest {
+
+    private MyList<Student> students;
+    private final Comparator<Student> groupComparator = new StudentGroupComparator();
+    private final Comparator<Student> gradeComparator = new StudentAverageGradeComparator();
+    private final Comparator<Student> recordComparator = new StudentRecordBookComparator();
+
+    @BeforeEach
+    void setUp() {
+        students = new MyLinkedList<>();
+        students.add(new Student("A12", 4.5, 12345));
+        students.add(new Student("B32", 3.8, 12346));
+        students.add(new Student("Z00", 4.9, 12347));
+        students.add(new Student("A12", 4.2, 12348));
+        students.add(new Student("B32", 5.0, 12349));
+    }
+
+    @Test
+    void testMergeSortByGroupNumber() {
+        SortStrategy<Student> strategy = new MergeSortStrategy<>();
+        strategy.sort(students, groupComparator);
+        assertOrder(students, "A12", "A12", "B32", "B32", "Z00");
+    }
+
+    @Test
+    void testMergeSortByAverageGrade() {
+        SortStrategy<Student> strategy = new MergeSortStrategy<>();
+        strategy.sort(students, gradeComparator);
+        assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0);
+    }
+
+    @Test
+    void testMergeSortByRecordBookNumber() {
+        SortStrategy<Student> strategy = new MergeSortStrategy<>();
+        strategy.sort(students, recordComparator);
+        assertOrder(students, 12345, 12346, 12347, 12348, 12349);
+    }
+
+    @Test
+    void testBubbleSortByGroupNumber() {
+        SortStrategy<Student> strategy = new BubbleSortStrategy<>();
+        strategy.sort(students, groupComparator);
+        assertOrder(students, "A12", "A12", "B32", "B32", "Z00");
+    }
+
+    @Test
+    void testBubbleSortByAverageGrade() {
+        SortStrategy<Student> strategy = new BubbleSortStrategy<>();
+        strategy.sort(students, gradeComparator);
+        assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0);
+    }
+
+    @Test
+    void testBubbleSortByRecordBookNumber() {
+        SortStrategy<Student> strategy = new BubbleSortStrategy<>();
+        strategy.sort(students, recordComparator);
+        assertOrder(students, 12345, 12346, 12347, 12348, 12349);
+    }
+
+    @Test
+    void testEvenOnlySortByRecordBookNumber() {
+        MyList<Student> list = new MyLinkedList<>();
+        list.add(new Student("A01", 4.5, 7));
+        list.add(new Student("A02", 4.5, 8));
+        list.add(new Student("A03", 4.5, 3));
+        list.add(new Student("A04", 4.5, 2));
+        list.add(new Student("A05", 4.5, 5));
+        list.add(new Student("A06", 4.5, 4));
+
+        EvenOnlyMergeSortStrategy<Student> strategy =
+                new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
+        strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
+
+        int[] expected = {7, 2, 3, 4, 5, 8};
+        for (int i = 0; i < list.size(); i++) {
+            assertEquals(expected[i], list.get(i).getRecordBookNumber());
+        }
+    }
+
+    @Test
+    void testEvenOnlyWithNoEvenElements() {
+        MyList<Student> list = new MyLinkedList<>();
+        list.add(new Student("A01", 4.5, 1));
+        list.add(new Student("A02", 4.5, 3));
+        list.add(new Student("A03", 4.5, 5));
+
+        EvenOnlyMergeSortStrategy<Student> strategy =
+                new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
+        strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
+
+        int[] expected = {1, 3, 5};
+        for (int i = 0; i < list.size(); i++) {
+            assertEquals(expected[i], list.get(i).getRecordBookNumber());
+        }
+    }
+
+    @Test
+    void testEvenOnlyWithAllEvenElements() {
+        MyList<Student> list = new MyLinkedList<>();
+        list.add(new Student("A01", 4.5, 4));
+        list.add(new Student("A02", 4.5, 2));
+        list.add(new Student("A03", 4.5, 6));
+
+        EvenOnlyMergeSortStrategy<Student> strategy =
+                new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
+        strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
+
+        int[] expected = {2, 4, 6};
+        for (int i = 0; i < list.size(); i++) {
+            assertEquals(expected[i], list.get(i).getRecordBookNumber());
+        }
+    }
+
+    @Test
+    void testSortEmptyList() {
+        MyList<Student> empty = new MyLinkedList<>();
+        SortStrategy<Student> strategy = new MergeSortStrategy<>();
+        strategy.sort(empty, groupComparator);
+        assertEquals(0, empty.size());
+    }
+
+    @Test
+    void testSortSingleElement() {
+        MyList<Student> single = new MyLinkedList<>();
+        single.add(new Student("A12", 4.5, 12345));
+        SortStrategy<Student> strategy = new MergeSortStrategy<>();
+        strategy.sort(single, groupComparator);
+        assertEquals(1, single.size());
+    }
+
+    private void assertOrder(MyList<Student> list, String... groups) {
+        assertEquals(groups.length, list.size());
+        for (int i = 0; i < groups.length; i++) {
+            assertEquals(groups[i], list.get(i).getGroupNumber());
+        }
+    }
+
+    private void assertOrder(MyList<Student> list, double... grades) {
+        assertEquals(grades.length, list.size());
+        for (int i = 0; i < grades.length; i++) {
+            assertEquals(grades[i], list.get(i).getAverageGrade(), 0.001);
+        }
+    }
+
+    private void assertOrder(MyList<Student> list, int... records) {
+        assertEquals(records.length, list.size());
+        for (int i = 0; i < records.length; i++) {
+            assertEquals(records[i], list.get(i).getRecordBookNumber());
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/test/java/ru/project/sorting/EvenOnlySortStrategyTest.java b/app/src/test/java/ru/project/sorting/EvenOnlySortStrategyTest.java
new file mode 100644
index 0000000..8d482bd
--- /dev/null
+++ b/app/src/test/java/ru/project/sorting/EvenOnlySortStrategyTest.java
@@ -0,0 +1,301 @@
+package ru.project.sorting;
+
+import org.junit.jupiter.api.Test;
+import ru.project.collection.MyLinkedList;
+import ru.project.collection.MyList;
+import ru.project.student.Student;
+
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+import java.util.Comparator;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class EvenOnlySortStrategyTest {
+
+    @Test
+    void shouldHandleEmptyList() {
+        MyList<Integer> list = new MyLinkedList<>();
+
+        EvenOnlySortStrategy<Integer> strategy =
+                new EvenOnlySortStrategy<>(
+                        new MergeSortStrategy<>(),
+                        value -> value
+                );
+
+        strategy.sort(list, Integer::compare);
+
+        assertEquals(0, list.size());
+    }
+
+    @Test
+    void shouldKeepSingleEvenElementUnchanged() {
+        MyList<Integer> list = new MyLinkedList<>();
+        list.add(4);
+
+        EvenOnlySortStrategy<Integer> strategy =
+                new EvenOnlySortStrategy<>(
+                        new MergeSortStrategy<>(),
+                        value -> value
+                );
+
+        strategy.sort(list, Integer::compare);
+
+        assertEquals(4, list.get(0));
+        assertEquals(1, list.size());
+    }
+
+    @Test
+    void shouldKeepSingleOddElementUnchanged() {
+        MyList<Integer> list = new MyLinkedList<>();
+        list.add(7);
+
+        EvenOnlySortStrategy<Integer> strategy =
+                new EvenOnlySortStrategy<>(
+                        new MergeSortStrategy<>(),
+                        value -> value
+                );
+
+        strategy.sort(list, Integer::compare);
+
+        assertEquals(7, list.get(0));
+        assertEquals(1, list.size());
+    }
+
+    @Test
+    void shouldHandleDuplicateEvenValues() {
+        MyList<Integer> list = new MyLinkedList<>();
+
+        list.add(8);
+        list.add(4);
+        list.add(8);
+        list.add(2);
+        list.add(4);
+
+        EvenOnlySortStrategy<Integer> strategy =
+                new EvenOnlySortStrategy<>(
+                        new MergeSortStrategy<>(),
+                        value -> value
+                );
+
+        strategy.sort(list, Integer::compare);
+
+        assertEquals(2, list.get(0));
+        assertEquals(4, list.get(1));
+        assertEquals(4, list.get(2));
+        assertEquals(8, list.get(3));
+        assertEquals(8, list.get(4));
+    }
+
+    @Test
+    void shouldKeepOddStudentObjectsAtSameIndexes() {
+        Student oddFirst = new Student("A01", 4.0, 7);
+        Student evenFirst = new Student("A02", 4.0, 8);
+        Student oddSecond = new Student("A03", 4.0, 3);
+        Student evenSecond = new Student("A04", 4.0, 2);
+        Student oddThird = new Student("A05", 4.0, 5);
+        Student evenThird = new Student("A06", 4.0, 4);
+
+        MyList<Student> students = new MyLinkedList<>();
+
+        students.add(oddFirst);
+        students.add(evenFirst);
+        students.add(oddSecond);
+        students.add(evenSecond);
+        students.add(oddThird);
+        students.add(evenThird);
+
+        EvenOnlySortStrategy<Student> strategy =
+                new EvenOnlySortStrategy<>(
+                        new MergeSortStrategy<>(),
+                        Student::getRecordBookNumber
+                );
+
+        strategy.sort(students, new StudentRecordBookComparator());
+
+        assertSame(oddFirst, students.get(0));
+        assertSame(oddSecond, students.get(2));
+        assertSame(oddThird, students.get(4));
+
+        assertEquals(2, students.get(1).getRecordBookNumber());
+        assertEquals(4, students.get(3).getRecordBookNumber());
+        assertEquals(8, students.get(5).getRecordBookNumber());
+    }
+
+    @Test
+    void shouldSortWhenStrategyPassedThroughConstructor() {
+        MyList<Integer> list = new MyLinkedList<>();
+
+        list.add(8);
+        list.add(2);
+        list.add(4);
+
+        EvenOnlySortStrategy<Integer> strategy =
+                new EvenOnlySortStrategy<>(
+                        new MergeSortStrategy<>()
+                );
+
+        strategy.setValueExtractor(value -> value);
+
+        strategy.sort(list, Integer::compare);
+
+        assertEquals(2, list.get(0));
+        assertEquals(4, list.get(1));
+        assertEquals(8, list.get(2));
+    }
+
+    @Test
+    void shouldSortOnlyEvenElements() {
+        MyList<Student> students = new MyLinkedList<>();
+
+        students.add(new Student("A01", 4.0, 7));
+        students.add(new Student("A02", 4.0, 8));
+        students.add(new Student("A03", 4.0, 3));
+        students.add(new Student("A04", 4.0, 2));
+        students.add(new Student("A05", 4.0, 5));
+        students.add(new Student("A06", 4.0, 4));
+
+        EvenOnlySortStrategy<Student> strategy = new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), Student::getRecordBookNumber);
+
+        strategy.sort(students, new StudentRecordBookComparator());
+
+        assertEquals(7, students.get(0).getRecordBookNumber());
+        assertEquals(2, students.get(1).getRecordBookNumber());
+        assertEquals(3, students.get(2).getRecordBookNumber());
+        assertEquals(4, students.get(3).getRecordBookNumber());
+        assertEquals(5, students.get(4).getRecordBookNumber());
+        assertEquals(8, students.get(5).getRecordBookNumber());
+
+        assertEquals(6, students.size());
+    }
+
+    @Test
+    void shouldSortAllEvenElements() {
+        MyList<Integer> list = new MyLinkedList<>();
+
+        list.add(8);
+        list.add(2);
+        list.add(6);
+        list.add(4);
+
+        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
+
+        strategy.sort(list, Integer::compare);
+
+        assertEquals(2, list.get(0));
+        assertEquals(4, list.get(1));
+        assertEquals(6, list.get(2));
+        assertEquals(8, list.get(3));
+    }
+
+    @Test
+    void shouldKeepOddElementsUnchanged() {
+        MyList<Integer> list = new MyLinkedList<>();
+
+        list.add(7);
+        list.add(3);
+        list.add(5);
+        list.add(1);
+
+        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
+
+        strategy.sort(list, Integer::compare);
+
+        assertEquals(7, list.get(0));
+        assertEquals(3, list.get(1));
+        assertEquals(5, list.get(2));
+        assertEquals(1, list.get(3));
+    }
+
+    @Test
+    void shouldThrowWhenSortStrategyIsNotSet() {
+        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>();
+
+        strategy.setValueExtractor(value -> value);
+
+        MyList<Integer> list = new MyLinkedList<>();
+        list.add(2);
+        list.add(4);
+
+        assertThrows(IllegalStateException.class, () -> strategy.sort(list, Integer::compare));
+    }
+
+    @Test
+    void shouldRejectNullSortStrategy() {
+        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>();
+
+        assertThrows(IllegalArgumentException.class, () -> strategy.setSortStrategy(null));
+    }
+
+    @Test
+    void shouldDelegateSortingToProvidedStrategy() {
+        MyList<Integer> list = new MyLinkedList<>();
+
+        list.add(7);
+        list.add(8);
+        list.add(3);
+        list.add(2);
+
+        RecordingSortStrategy recordingStrategy = new RecordingSortStrategy();
+
+        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(recordingStrategy, value -> value);
+
+        strategy.sort(list, Integer::compare);
+
+        assertTrue(recordingStrategy.wasCalled);
+        assertEquals(2, recordingStrategy.receivedSize);
+        assertEquals(8, recordingStrategy.firstReceivedElement);
+        assertEquals(2, recordingStrategy.secondReceivedElement);
+    }
+
+    @Test
+    void shouldUseNewStrategyAfterReplacement() {
+        RecordingSortStrategy firstStrategy = new RecordingSortStrategy();
+
+        RecordingSortStrategy secondStrategy = new RecordingSortStrategy();
+
+        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(firstStrategy, value -> value);
+
+        MyList<Integer> firstList = new MyLinkedList<>();
+        firstList.add(4);
+        firstList.add(2);
+
+        strategy.sort(firstList, Integer::compare);
+
+        assertTrue(firstStrategy.wasCalled);
+
+        strategy.setSortStrategy(secondStrategy);
+
+        MyList<Integer> secondList = new MyLinkedList<>();
+        secondList.add(8);
+        secondList.add(6);
+
+        strategy.sort(secondList, Integer::compare);
+
+        assertTrue(secondStrategy.wasCalled);
+    }
+
+    private static class RecordingSortStrategy implements SortStrategy<Integer> {
+
+        private boolean wasCalled;
+        private int receivedSize;
+        private Integer firstReceivedElement;
+        private Integer secondReceivedElement;
+
+        @Override
+        public void sort(MyList<Integer> list, Comparator<Integer> comparator) {
+            wasCalled = true;
+            receivedSize = list.size();
+
+            if (list.size() > 0) {
+                firstReceivedElement = list.get(0);
+            }
+
+            if (list.size() > 1) {
+                secondReceivedElement = list.get(1);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/test/java/ru/project/student/StudentTest.java b/app/src/test/java/ru/project/student/StudentTest.java
index e9a7434..09cf2e7 100644
--- a/app/src/test/java/ru/project/student/StudentTest.java
+++ b/app/src/test/java/ru/project/student/StudentTest.java
@@ -2,167 +2,144 @@ package ru.project.student;
 
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
 
 
 class StudentTest {
-    @Test
-    void shouldCreateValidStudent() {
-        Student student = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(4.5)
-                .setRecordBookNumber("12345")
-                .build();
 
-        assertEquals("101", student.getGroupNumber());
+    @Test
+    void testValidStudentCreation() {
+        Student student = new Student("A12", 4.5, 12345);
+        assertEquals("A12", student.getGroupNumber());
         assertEquals(4.5, student.getAverageGrade());
-        assertEquals("12345", student.getRecordBookNumber());
+        assertEquals(12345, student.getRecordBookNumber());
     }
 
     @Test
-    void shouldThrowExceptionWhenGroupNumberIsEmpty() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber("")
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber("12345")
-                    .build();
-        });
+    void testValidGroupNumbers() {
+        assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
+        assertDoesNotThrow(() -> new Student("B32", 4.5, 1));
+        assertDoesNotThrow(() -> new Student("Z00", 4.5, 1));
     }
 
     @Test
-    void shouldThrowExceptionWhenAverageGradeIsGreaterThanFive() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber("101")
-                    .setAverageGrade(6.0)
-                    .setRecordBookNumber("12345")
-                    .build();
-        });
+    void testInvalidGroupNumbers() {
+        assertThrows(IllegalArgumentException.class, () -> new Student("a12", 4.5, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("A1", 4.5, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("A123", 4.5, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("AA1", 4.5, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("а1А", 4.5, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("аа!!а123", 4.5, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("23фи!12", 4.5, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("№№###*()", 4.5, 1));
     }
 
     @Test
-    void shouldThrowExceptionWhenAverageGradeIsLessThanZero() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber("101")
-                    .setAverageGrade(-1.0)
-                    .setRecordBookNumber("12345")
-                    .build();
-        });
+    void testValidAverageGrades() {
+        assertDoesNotThrow(() -> new Student("A12", 0.0, 1));
+        assertDoesNotThrow(() -> new Student("A12", 5.0, 1));
     }
 
     @Test
-    void shouldCreateStudentWhenAverageGradeIsZero() {
-        Student student = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(0.0)
-                .setRecordBookNumber("12345")
-                .build();
-
-        assertEquals(0.0, student.getAverageGrade());
+    void testInvalidAverageGrades() {
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", -1.0, 1));
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 6.0, 1));
     }
 
     @Test
-    void shouldCreateStudentWhenAverageGradeIsFive() {
-        Student student = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(5.0)
-                .setRecordBookNumber("12345")
-                .build();
-
-        assertEquals(5.0, student.getAverageGrade());
+    void testValidRecordBookNumbers() {
+        assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
+        assertDoesNotThrow(() -> new Student("A12", 4.5, 12345));
     }
 
     @Test
-    void shouldThrowExceptionWhenRecordBookNumberIsEmpty() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber("101")
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber("")
-                    .build();
-        });
+    void testInvalidRecordBookNumbers() {
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, 0));
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, -1));
     }
 
     @Test
-    void shouldThrowExceptionWhenGroupNumberIsNull() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber(null)
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber("12345")
-                    .build();
-        });
+    void testWithGroupNumber() {
+        Student original = new Student("A12", 4.5, 12345);
+        Student updated = original.withGroupNumber("B32");
+
+        assertNotSame(original, updated);
+        assertEquals("B32", updated.getGroupNumber());
+        assertEquals(4.5, updated.getAverageGrade());
+        assertEquals(12345, updated.getRecordBookNumber());
+
+        assertEquals("A12", original.getGroupNumber());
     }
 
     @Test
-    void shouldThrowExceptionWhenGroupNumberIsBlank() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber("   ")
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber("12345")
-                    .build();
-        });
+    void testWithAverageGrade() {
+        Student original = new Student("A12", 4.5, 12345);
+        Student updated = original.withAverageGrade(4.8);
+
+        assertNotSame(original, updated);
+        assertEquals(4.8, updated.getAverageGrade());
+        assertEquals("A12", updated.getGroupNumber());
+        assertEquals(12345, updated.getRecordBookNumber());
+
+        assertEquals(4.5, original.getAverageGrade());
     }
 
     @Test
-    void shouldThrowExceptionWhenRecordBookNumberIsNull() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber("101")
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber(null)
-                    .build();
-        });
+    void testWithRecordBookNumber() {
+        Student original = new Student("A12", 4.5, 12345);
+        Student updated = original.withRecordBookNumber(99999);
+
+        assertNotSame(original, updated);
+        assertEquals(99999, updated.getRecordBookNumber());
+        assertEquals("A12", updated.getGroupNumber());
+        assertEquals(4.5, updated.getAverageGrade());
+
+        assertEquals(12345, original.getRecordBookNumber());
     }
 
     @Test
-    void shouldThrowExceptionWhenRecordBookNumberIsBlank() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new StudentBuilder()
-                    .setGroupNumber("101")
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber("   ")
-                    .build();
-        });
+    void testWithInvalidGroupNumber() {
+        Student original = new Student("A12", 4.5, 12345);
+        assertThrows(IllegalArgumentException.class,
+                () -> original.withGroupNumber("a12"));
+        assertEquals("A12", original.getGroupNumber()); // не изменился
     }
 
     @Test
-    void shouldReturnTrueWhenStudentsAreEqual() {
-        Student student1 = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(4.5)
-                .setRecordBookNumber("12345")
-                .build();
-
-        Student student2 = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(4.5)
-                .setRecordBookNumber("12345")
-                .build();
-
-        assertEquals(student1, student2);
-        assertEquals(student1.hashCode(), student2.hashCode());
+    void testWithInvalidAverageGrade() {
+        Student original = new Student("A12", 4.5, 12345);
+        assertThrows(IllegalArgumentException.class,
+                () -> original.withAverageGrade(6.0));
+        assertEquals(4.5, original.getAverageGrade());
     }
 
     @Test
-    void shouldReturnFalseWhenStudentsAreDifferent() {
-        Student student1 = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(4.5)
-                .setRecordBookNumber("12345")
-                .build();
+    void testWithInvalidRecordBookNumber() {
+        Student original = new Student("A12", 4.5, 12345);
+        assertThrows(IllegalArgumentException.class,
+                () -> original.withRecordBookNumber(0));
+        assertEquals(12345, original.getRecordBookNumber());
+    }
 
-        Student student2 = new StudentBuilder()
-                .setGroupNumber("102")
-                .setAverageGrade(4.5)
-                .setRecordBookNumber("12345")
-                .build();
+    @Test
+    void testEqualsAndHashCode() {
+        Student s1 = new Student("A12", 4.5, 12345);
+        Student s2 = new Student("A12", 4.5, 12345);
+        Student s3 = new Student("B32", 4.5, 12345);
+        Student s4 = new Student("A12", 4.8, 12345);
+        Student s5 = new Student("A12", 4.5, 99999);
 
-        assertNotEquals(student1, student2);
+        assertEquals(s1, s2);
+        assertEquals(s1.hashCode(), s2.hashCode());
+
+        assertNotEquals(s1, s3);
+        assertNotEquals(s1, s4);
+        assertNotEquals(s1, s5);
+        assertNotEquals(s1, null);
+        assertNotEquals(s1, "some string");
     }
 }