finish updating array implementations

Author: JavaSaBr

rlib-common/src/main/java/com/ss/rlib/common/util/array/ArrayFactory.java

@@ -1,8 +1,7 @@
 package com.ss.rlib.common.util.array;
 
-import static com.ss.rlib.common.util.ClassUtils.unsafeCast;
+import static com.ss.rlib.common.util.ClassUtils.unsafeNNCast;
 import com.ss.rlib.common.util.ArrayUtils;
-import com.ss.rlib.common.util.ClassUtils;
 import com.ss.rlib.common.util.array.impl.*;
 import org.jetbrains.annotations.NotNull;
 
@@ -16,174 +15,87 @@ public class ArrayFactory {
     public static final Array<?> EMPTY_ARRAY = newReadOnlyArray(ArrayUtils.EMPTY_OBJECT_ARRAY);
 
     /**
-     * Wrap arguments as an array collection..
+     * Wrap arguments as an array collection.
      *
-     * @param <E>  the argument's type.
      * @param args the elements to be wrapped.
+     * @param <E>  the element's type.
      * @return the new array collection with the wrapped arguments.
      */
     @SafeVarargs
-    public static <E> Array<E> asArray(@NotNull E... args) {
+    public static <E> @NotNull Array<E> asArray(@NotNull E... args) {
         return new FastArray<>(args);
     }
 
     /**
-     * Create the new array.
+     * Create the new mutable array.
      *
-     * @param <E>  the type parameter
      * @param type the type of the array.
-     * @return the new array.
+     * @param <E>  the element's type.
+     * @return the new mutable array collection.
      */
-    public static <E> Array<E> newArray(@NotNull Class<? super E> type) {
+    public static <E> @NotNull Array<E> newArray(@NotNull Class<? super E> type) {
         return newUnsafeArray(type);
     }
 
-    /**
-     * Create the new copy on modify array.
-     *
-     * @param <E>  the element's type.
-     * @param type the element's type.
-     * @return the new array.
-     */
-    public static <E> Array<E> newCopyOnModifyArray(@NotNull Class<? super E> type) {
+    public static <E> @NotNull Array<E> newArray(@NotNull Class<? super E> type, int capacity) {
+        return newUnsafeArray(type, capacity);
+    }
+
+    public static <E> @NotNull Array<E> newCopyOnModifyArray(@NotNull Class<? super E> type) {
         return new CopyOnModifyArray<>(type, 0);
     }
 
-    /**
-     * Create the new unsafe array.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new unsafe array.
-     */
-    public static <E> UnsafeArray<E> newUnsafeArray(@NotNull Class<? super E> type) {
+    public static <E> @NotNull UnsafeArray<E> newUnsafeArray(@NotNull Class<? super E> type) {
         return new FastArray<>(type);
     }
 
-    /**
-     * Create the new array.
-     *
-     * @param <E>      the type parameter
-     * @param type     the type of the array.
-     * @param capacity the init size of the array.
-     * @return the new array.
-     */
-    public static <E> Array<E> newArray(@NotNull Class<? super E> type, int capacity) {
-        return newUnsafeArray(type, capacity);
+    public static <E> UnsafeArray<E> newUnsafeArray(@NotNull Class<? super E> type, int capacity) {
+        return new FastArray<>(type, capacity);
     }
 
-    /**
-     * Create a new read only array.
-     *
-     * @param <E> the element's type.
-     * @return the new read only array.
-     */
-    public static <E> ReadOnlyArray<E> newReadOnlyArray(@NotNull E[] elements) {
+    public static <E> @NotNull ReadOnlyArray<E> newReadOnlyArray(@NotNull E[] elements) {
         return new ReadOnlyFastArray<>(elements);
     }
 
-    /**
-     * Creates the new unsafe array.
-     *
-     * @param <E>      the type parameter
-     * @param type     the type of the array.
-     * @param capacity the init size of the array.
-     * @return the new unsafe array.
-     */
-    public static <E> UnsafeArray<E> newUnsafeArray(@NotNull Class<? super E> type, int capacity) {
-        return new FastArray<>(type, capacity);
-    }
-
-    /**
-     * Create the new array set.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new array.
-     */
-    public static <E> Array<E> newArraySet(@NotNull Class<? super E> type) {
+    public static <E> @NotNull Array<E> newArraySet(@NotNull Class<? super E> type) {
         return new FastArraySet<>(type);
     }
 
-    /**
-     * Create the new concurrent array.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new array.
-     */
-    public static <E> ConcurrentArray<E> newConcurrentReentrantRWLockArray(@NotNull Class<? super E> type) {
+    public static <E> @NotNull ConcurrentArray<E> newConcurrentReentrantRWLockArray(@NotNull Class<? super E> type) {
         return new ConcurrentReentrantRWLockArray<>(type);
     }
 
-    /**
-     * Create the new concurrent array set.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new array.
-     */
-    public static <E> ConcurrentArray<E> newConcurrentReentrantRWLockArraySet(@NotNull Class<? super E> type) {
+    public static <E> @NotNull ConcurrentArray<E> newConcurrentReentrantRWLockArraySet(@NotNull Class<? super E> type) {
         return new ConcurrentReentrantRWLockArraySet<>(type);
     }
 
-    /**
-     * Create the new concurrent array.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new array.
-     */
-    public static <E> ConcurrentArray<E> newConcurrentAtomicARSWLockArray(@NotNull Class<? super E> type) {
+    public static <E> @NotNull ConcurrentArray<E> newConcurrentAtomicARSWLockArray(@NotNull Class<? super E> type) {
         return new ConcurrentAtomicARSWLockArray<>(type);
     }
 
-    /**
-     * Create the new stamped lock based concurrent array.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new array.
-     */
-    public static <E> ConcurrentArray<E> newConcurrentStampedLockArray(@NotNull Class<? super E> type) {
+    public static <E> @NotNull ConcurrentArray<E> newConcurrentStampedLockArray(@NotNull Class<? super E> type) {
         return new ConcurrentStampedLockArray<>(type);
     }
 
-    /**
-     * Create the new stamped lock based concurrent array.
-     *
-     * @param array the source array.
-     * @return the new array.
-     */
-    public static <E> ConcurrentArray<E> newConcurrentStampedLockArray(E @NotNull [] array) {
+    public static <E> @NotNull ConcurrentArray<E> newConcurrentStampedLockArray(E @NotNull [] array) {
 
-        Class<? super E> type = ClassUtils.unsafeNNCast(array.getClass().getComponentType());
+        Class<? super E> type = unsafeNNCast(array.getClass().getComponentType());
 
         var result = new ConcurrentStampedLockArray<E>(type, array.length);
         result.addAll(array);
 
         return result;
     }
 
-    /**
-     * Create the new sorted array.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new array.
-     */
-    public static <E extends Comparable<E>> Array<E> newSortedArray(@NotNull Class<? super E> type) {
-        return new SortedArray<>(unsafeCast(type));
+    public static <E> @NotNull ConcurrentArray<E> newConcurrentStampedLockArraySet(@NotNull Class<? super E> type) {
+        return new ConcurrentStampedLockArraySet<>(type);
     }
 
-    /**
-     * Create the new synchronized array.
-     *
-     * @param <E>  the type parameter
-     * @param type the type of the array.
-     * @return the new array.
-     */
-    public static <E> Array<E> newSynchronizedArray(@NotNull Class<? super E> type) {
+    public static <E extends Comparable<E>> @NotNull Array<E> newSortedArray(@NotNull Class<? super E> type) {
+        return new SortedFastArray<>(unsafeNNCast(type));
+    }
+
+    public static <E> @NotNull Array<E> newSynchronizedArray(@NotNull Class<? super E> type) {
         return new SynchronizedArray<>(type);
     }
 
@@ -199,77 +111,30 @@ public static <E> Array<E> newSynchronizedArray(@NotNull Class<? super E> type)
         return new DefaultIntegerArray(numbers);
     }
 
-    /**
-     * Create the a long array.
-     *
-     * @return the new array.
-     */
     public static @NotNull LongArray newLongArray() {
         return new FastLongArray();
     }
 
-    /**
-     * Create the a long array.
-     *
-     * @param capacity the init size of the array.
-     * @return the new array.
-     */
     public static @NotNull LongArray newLongArray(int capacity) {
         return new FastLongArray(capacity);
     }
 
-    /**
-     * Create a new float array.
-     *
-     * @param elements the elements of the new float array.
-     * @return the new float array.
-     * @since 8.1.0
-     */
     public static @NotNull float[] toFloatArray(float... elements) {
         return elements;
     }
 
-    /**
-     * Create a new int array.
-     *
-     * @param elements the elements of the new int array.
-     * @return the new int array.
-     * @since 8.1.0
-     */
     public static @NotNull int[] toIntArray(int... elements) {
         return elements;
     }
 
-    /**
-     * Create a new long array.
-     *
-     * @param elements the elements of the new long array.
-     * @return the new long array.
-     * @since 9.0.3
-     */
     public static @NotNull long[] toLongArray(long... elements) {
         return elements;
     }
 
-    /**
-     * Create a new boolean array.
-     *
-     * @param elements the elements of the new boolean array.
-     * @return the new boolean array.
-     * @since 9.2.1
-     */
     public static @NotNull boolean[] toBooleanArray(boolean... elements) {
         return elements;
     }
 
-    /**
-     * Create a new object array.
-     *
-     * @param <T>      the base array's element type.
-     * @param <K>      the array's element type.
-     * @param elements the elements of the new array.
-     * @return the new array.
-     */
     @SafeVarargs
     public static <T, K extends T> @NotNull T[] toArray(K... elements) {
         return elements;

rlib-common/src/main/java/com/ss/rlib/common/util/array/ReadOnlyArray.java

@@ -40,7 +40,7 @@ public interface ReadOnlyArray<E> extends Array<E> {
 
     @Override
     @Deprecated
-    boolean slowRemove(@NotNull Object object);
+    @NotNull E remove(int index);
 
     @Override
     @Deprecated

rlib-common/src/main/java/com/ss/rlib/common/util/array/impl/AbstractArray.java

@@ -8,9 +8,9 @@
 import java.util.function.Function;
 
 /**
- * The base implementation of the {@link Array}.
+ * The base implementation of dynamic arrays.
  *
- * @param <E> the type parameter
+ * @param <E> the array's element type.
  * @author JavaSaBr
  */
 public abstract class AbstractArray<E> implements Array<E> {
@@ -56,27 +56,16 @@ public void clear() {
     }
 
     @Override
-    public final void free() {
+    public void free() {
         clear();
     }
 
     @Override
-    public AbstractArray<E> clone() throws CloneNotSupportedException {
-        return ClassUtils.unsafeCast(super.clone());
+    public @NotNull AbstractArray<E> clone() throws CloneNotSupportedException {
+        return ClassUtils.unsafeNNCast(super.clone());
     }
 
-    /**
-     * Sets array.
-     *
-     * @param array the new array.
-     */
-    protected abstract void setArray(@NotNull E[] array);
-
-    /**
-     * Sets size.
-     *
-     * @param size the new size of the array.
-     */
+    protected abstract void setArray(E @NotNull [] array);
     protected abstract void setSize(int size);
 
     @Override