add sort method to arrays

Author: JavaSaBr

rlib-collections/src/main/java/javasabr/rlib/collections/array/MutableArray.java

@@ -1,6 +1,7 @@
 package javasabr.rlib.collections.array;
 
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.function.Consumer;
 import java.util.function.IntFunction;
@@ -48,4 +49,8 @@ default void forEach(Consumer<? super E> action) {
 
   @Override
   UnsafeMutableArray<E> asUnsafe();
+  
+  void sort();
+  
+  void sort(Comparator<E> comparator);
 }

rlib-collections/src/main/java/javasabr/rlib/collections/array/impl/AbstractMutableArray.java

@@ -2,6 +2,7 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.Spliterator;
@@ -10,6 +11,7 @@
 import java.util.stream.StreamSupport;
 import javasabr.rlib.collections.array.Array;
 import javasabr.rlib.collections.array.UnsafeMutableArray;
+import javasabr.rlib.common.util.ObjectUtils;
 import lombok.AccessLevel;
 import lombok.experimental.FieldDefaults;
 import org.jspecify.annotations.Nullable;
@@ -226,6 +228,30 @@ public UnsafeMutableArray<E> asUnsafe() {
     return this;
   }
 
+  @Override
+
+  public void sort() {
+    sortInternalArray(wrapped(), size());
+  }
+
+  @SuppressWarnings({
+      "rawtypes",
+      "unchecked"
+  })
+  protected void sortInternalArray(@Nullable E[] array, int size) {
+    if (Comparable.class.isAssignableFrom(type())) {
+      Comparable[] wrapped = (Comparable[]) array;
+      Arrays.sort(wrapped, 0, size, Comparator.naturalOrder());
+    } else {
+      Arrays.sort(array, 0, size, Comparator.comparingInt(ObjectUtils::hash));
+    }
+  }
+  
+  @Override
+  public void sort(Comparator<E> comparator) {
+    Arrays.sort(wrapped(), 0, size(), comparator);
+  }
+
   protected static void validateCapacity(int capacity) {
     if (capacity < 0) {
       throw new IllegalArgumentException("Capacity cannot be negative");

rlib-collections/src/main/java/javasabr/rlib/collections/array/impl/CopyOnWriteMutableArray.java

@@ -2,6 +2,7 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.ConcurrentModificationException;
 import java.util.concurrent.atomic.AtomicReference;
 import javasabr.rlib.collections.array.Array;
@@ -208,4 +209,30 @@ protected int getAndIncrementSize() {
   protected int decrementAnGetSize() {
     return 0;
   }
+
+  @Override
+  public void sort() {
+    for (int i = 0; i < LIMIT_ATTEMPTS; i++) {
+      @Nullable E[] original = wrapped.get();
+      @Nullable E[] copy = Arrays.copyOf(original, original.length);
+      sortInternalArray(copy, copy.length);
+      if (wrapped.compareAndSet(original, copy)) {
+        return;
+      }
+    }
+    throw new ConcurrentModificationException("Cannot successfully sort this array");
+  }
+
+  @Override
+  public void sort(Comparator<E> comparator) {
+    for (int i = 0; i < LIMIT_ATTEMPTS; i++) {
+      @Nullable E[] original = wrapped.get();
+      @Nullable E[] copy = Arrays.copyOf(original, original.length);
+      Arrays.sort(copy, comparator);
+      if (wrapped.compareAndSet(original, copy)) {
+        return;
+      }
+    }
+    throw new ConcurrentModificationException("Cannot successfully sort this array");
+  }
 }

rlib-collections/src/test/java/javasabr/rlib/collections/array/MutableArrayTest.java

@@ -1,5 +1,6 @@
 package javasabr.rlib.collections.array;
 
+import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.Assertions;
@@ -253,6 +254,36 @@ void shouldRenderToStringCorrectly(MutableArray<String> mutableArray) {
         mutableArray.toString());
   }
 
+  @ParameterizedTest
+  @MethodSource("generateMutableArrays")
+  @DisplayName("should sort array correctly")
+  void shouldSortArrayCorrectly(MutableArray<String> mutableArray) {
+    // given:
+    mutableArray.addAll(Array.of("10", "99", "5", "3", "77", "45", "25", "56"));
+    
+    // when:
+    mutableArray.sort();
+    
+    // then:
+    var expected = Array.of("10", "25", "3", "45", "5", "56", "77", "99");
+    Assertions.assertEquals(expected, mutableArray);
+  }
+
+  @ParameterizedTest
+  @MethodSource("generateMutableArrays")
+  @DisplayName("should sort array correctly")
+  void shouldSortArrayUsingComparatorCorrectly(MutableArray<String> mutableArray) {
+    // given:
+    mutableArray.addAll(Array.of("10", "99", "5", "3", "77", "45", "25", "56"));
+
+    // when:
+    mutableArray.sort(Comparator.comparingInt(Integer::parseInt));
+
+    // then:
+    var expected = Array.of("3", "5", "10", "25", "45", "56", "77", "99");
+    Assertions.assertEquals(expected, mutableArray);
+  }
+
   private static Stream<Arguments> generateMutableArrays() {
     return Stream.of(
         Arguments.of(ArrayFactory.mutableArray(String.class)),