refactor: unify code style and fix minor merge issues

app/src/main/java/ru/project/sorting/BubbleSortStrategy.java

@@ -1,24 +1,24 @@
 package ru.project.sorting;
 
-import ru.project.list.MyList;
 import java.util.Comparator;
+import ru.project.collection.MyList;
 
 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);
-                }
-            }
-        }
+  @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);
+        }
+      }
+    }
+  }
+}

app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java

@@ -1,84 +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;
+import ru.project.collection.MyList;
 
 public class EvenOnlyMergeSortStrategy<T> implements SortStrategy<T> {
 
-    private final ToIntFunction<T> valueExtractor;
+  private final ToIntFunction<T> valueExtractor;
 
-    public EvenOnlyMergeSortStrategy(ToIntFunction<T> valueExtractor) {
-        this.valueExtractor = 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;
     }
 
-    @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<>();
 
-        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));
-        }
+    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);
+      }
     }
 
-    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);
+    if (evenElements.size() <= 1) {
+      return;
     }
 
-    private List<T> merge(List<T> left, List<T> right, Comparator<T> comparator) {
-        List<T> result = new ArrayList<>();
-        int i = 0, j = 0;
+    List<T> sortedEven = mergeSort(evenElements, comparator);
 
-        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;
+    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;
+  }
+}

app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java

@@ -1,94 +1,89 @@
 package ru.project.sorting;
 
-import ru.project.collection.MyLinkedList;
-import ru.project.collection.MyList;
-
 import java.util.Comparator;
 import java.util.function.ToIntFunction;
+import ru.project.collection.MyLinkedList;
+import ru.project.collection.MyList;
 
 public class EvenOnlySortStrategy<T> implements SortStrategy<T> {
 
-    private SortStrategy<T> sortStrategy;
-    private ToIntFunction<T> valueExtractor;
+  private SortStrategy<T> sortStrategy;
+  private ToIntFunction<T> valueExtractor;
 
-    public EvenOnlySortStrategy() {
+  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");
     }
 
-    public EvenOnlySortStrategy(SortStrategy<T> sortStrategy) {
-        setSortStrategy(sortStrategy);
+    this.sortStrategy = sortStrategy;
+  }
+
+  public void setValueExtractor(ToIntFunction<T> valueExtractor) {
+    if (valueExtractor == null) {
+      throw new IllegalArgumentException("Value extractor must not be null");
     }
 
-    public EvenOnlySortStrategy(
-            SortStrategy<T> sortStrategy,
-            ToIntFunction<T> valueExtractor
-    ) {
-        setSortStrategy(sortStrategy);
-        setValueExtractor(valueExtractor);
+    this.valueExtractor = valueExtractor;
+  }
+
+  @Override
+  public void sort(MyList<T> list, Comparator<T> comparator) {
+    if (sortStrategy == null) {
+      throw new IllegalStateException("Sort strategy is not set");
     }
 
-    public void setSortStrategy(SortStrategy<T> sortStrategy) {
-        if (sortStrategy == null) {
-            throw new IllegalArgumentException("Sort strategy must not be null");
-        }
-
-        this.sortStrategy = sortStrategy;
+    if (valueExtractor == null) {
+      throw new IllegalStateException("Value extractor is not set");
     }
 
-    public void setValueExtractor(ToIntFunction<T> valueExtractor) {
-        if (valueExtractor == null) {
-            throw new IllegalArgumentException("Value extractor must not be null");
-        }
-
-        this.valueExtractor = valueExtractor;
+    if (list == null || list.size() <= 1) {
+      return;
     }
 
-    @Override
-    public void sort(MyList<T> list, Comparator<T> comparator) {
-        if (sortStrategy == null) {
-            throw new IllegalStateException("Sort strategy is not set");
-        }
+    int evenCount = 0;
 
-        if (valueExtractor == null) {
-            throw new IllegalStateException("Value extractor is not set");
-        }
+    for (int i = 0; i < list.size(); i++) {
+      T element = list.get(i);
 
-        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));
-        }
+      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));
+    }
+  }
+}

app/src/main/java/ru/project/sorting/MergeSortStrategy.java

@@ -1,67 +1,66 @@
 package ru.project.sorting;
 
-import ru.project.collection.MyList;
-
 import java.util.Comparator;
+import ru.project.collection.MyList;
 
 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);
+  @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);
     }
 
-    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);
+    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++;
     }
 
-    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++;
-        }
+    while (i < leftSize) {
+      list.set(k, leftArray[i]);
+      i++;
+      k++;
     }
-}
+    while (j < rightSize) {
+      list.set(k, rightArray[j]);
+      j++;
+      k++;
+    }
+  }
+}

app/src/main/java/ru/project/sorting/SortStrategy.java

@@ -1,9 +1,8 @@
 package ru.project.sorting;
 
+import java.util.Comparator;
 import ru.project.collection.MyList;
 
-import java.util.Comparator;
-
 public interface SortStrategy<T> {
-    void sort(MyList<T> list, Comparator<T> comparator);
-}
+  void sort(MyList<T> list, Comparator<T> comparator);
+}

app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java

@@ -1,12 +1,12 @@
 package ru.project.sorting;
 
-import ru.project.student.Student;
 import java.util.Comparator;
+import ru.project.student.Student;
 
 public class StudentAverageGradeComparator implements Comparator<Student> {
 
-    @Override
-    public int compare(Student s1, Student s2) {
-        return Double.compare(s1.getAverageGrade(), s2.getAverageGrade());
-    }
-}
+  @Override
+  public int compare(Student s1, Student s2) {
+    return Double.compare(s1.getAverageGrade(), s2.getAverageGrade());
+  }
+}

app/src/main/java/ru/project/sorting/StudentGroupComparator.java

@@ -1,12 +1,12 @@
 package ru.project.sorting;
 
-import ru.project.student.Student;
 import java.util.Comparator;
+import ru.project.student.Student;
 
 public class StudentGroupComparator implements Comparator<Student> {
 
-    @Override
-    public int compare(Student s1, Student s2) {
-        return s1.getGroupNumber().compareTo(s2.getGroupNumber());
-    }
+  @Override
+  public int compare(Student s1, Student s2) {
+    return s1.getGroupNumber().compareTo(s2.getGroupNumber());
+  }
 }

app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java

@@ -1,12 +1,12 @@
 package ru.project.sorting;
 
-import ru.project.student.Student;
 import java.util.Comparator;
+import ru.project.student.Student;
 
 public class StudentRecordBookComparator implements Comparator<Student> {
 
-    @Override
-    public int compare(Student s1, Student s2) {
-        return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
-    }
-}
+  @Override
+  public int compare(Student s1, Student s2) {
+    return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
+  }
+}

app/src/main/java/ru/project/student/Student.java

@@ -54,6 +54,10 @@ 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;
   }