Move new sort methods to a new class and add primitive versions.

This avoid growing ArrayUtils even more while keeping the new class
focused on sort APIs.

src/main/java/org/apache/commons/lang3/ArraySorter.java

@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.lang3;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * Sorts and returns arrays in the fluent style.
+ *
+ * @since 3.12
+ */
+public class ArraySorter {
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(byte[])
+     */
+    public static byte[] sort(final byte[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(char[])
+     */
+    public static char[] sort(final char[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(double[])
+     */
+    public static double[] sort(final double[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(float[])
+     */
+    public static float[] sort(final float[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(int[])
+     */
+    public static int[] sort(final int[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(long[])
+     */
+    public static long[] sort(final long[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(short[])
+     */
+    public static short[] sort(final short[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param <T> the array type.
+     * @param array the array to sort.
+     * @return the given array.
+     * @see Arrays#sort(Object[])
+     */
+    public static <T> T[] sort(final T[] array) {
+        Arrays.sort(array);
+        return array;
+    }
+
+    /**
+     * Sorts and returns the given array.
+     *
+     * @param <T> the array type.
+     * @param array the array to sort.
+     * @param comparator the comparator to determine the order of the array. A {@code null} value uses the elements'
+     *        {@link Comparable natural ordering}.
+     * @return the given array.
+     * @see Arrays#sort(Object[])
+     */
+    public static <T> T[] sort(final T[] array, final Comparator<? super T> comparator) {
+        Arrays.sort(array, comparator);
+        return array;
+    }
+
+}

src/main/java/org/apache/commons/lang3/ArrayUtils.java

@@ -7860,36 +7860,6 @@ public static int indexOf(final int[] array, final int valueToFind, int startInd
         }
     }
 
-    /**
-     * Sorts and returns the given array.
-     *
-     * @param <T> the array type.
-     * @param array the array to sort.
-     * @return the given array.
-     * @see Arrays#sort(Object[])
-     * @since 3.12
-     */
-    public static <T> T[] sort(final T[] array) {
-        Arrays.sort(array);
-        return array;
-    }
-
-    /**
-     * Sorts and returns the given array.
-     *
-     * @param <T> the array type.
-     * @param array the array to sort.
-     * @param comparator the comparator to determine the order of the array.
-     *        A {@code null} value uses the elements' {@link Comparable natural ordering}.
-     * @return the given array.
-     * @see Arrays#sort(Object[])
-     * @since 3.12
-     */
-    public static <T> T[] sort(final T[] array, final Comparator<? super T> comparator) {
-        Arrays.sort(array, comparator);
-        return array;
-    }
-
     /**
      * <p>Produces a new {@code boolean} array containing the elements
      * between the start and end indices.

src/test/java/org/apache/commons/lang3/ArraySorterTest.java

@@ -0,0 +1,100 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
+public class ArraySorterTest {
+
+    @Test
+    public void testSortByteArray() {
+        final byte[] array1 = {2, 1};
+        final byte[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+    @Test
+    public void testSortCharArray() {
+        final char[] array1 = {2, 1};
+        final char[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+    @Test
+    public void testSortComparable() {
+        final String[] array1 = ArrayUtils.toArray("foo", "bar");
+        final String[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2, String::compareTo));
+    }
+
+    @Test
+    public void testSortDoubleArray() {
+        final double[] array1 = {2, 1};
+        final double[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+    @Test
+    public void testSortFloatArray() {
+        final float[] array1 = {2, 1};
+        final float[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+    @Test
+    public void testSortIntArray() {
+        final int[] array1 = {2, 1};
+        final int[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+    @Test
+    public void testSortLongArray() {
+        final long[] array1 = {2, 1};
+        final long[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+    @Test
+    public void testSortObjects() {
+        final String[] array1 = ArrayUtils.toArray("foo", "bar");
+        final String[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+    @Test
+    public void testSortShortArray() {
+        final short[] array1 = {2, 1};
+        final short[] array2 = array1.clone();
+        Arrays.sort(array1);
+        assertArrayEquals(array1, ArraySorter.sort(array2));
+    }
+
+}

src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java

@@ -5129,20 +5129,6 @@ public class ArrayUtilsTest {
         }
     }
 
-    public void testSort() {
-        final String[] array1 = ArrayUtils.toArray("foo", "bar");
-        final String[] array2 = array1.clone();
-        Arrays.sort(array1);
-        assertEquals(array1, ArrayUtils.sort(array2));
-    }
-
-    public void testSortComparable() {
-        final String[] array1 = ArrayUtils.toArray("foo", "bar");
-        final String[] array2 = array1.clone();
-        Arrays.sort(array1);
-        assertEquals(array1, ArrayUtils.sort(array2, String::compareTo));
-    }
-
     @Test
     public void testSubarrayBoolean() {
         final boolean[] nullArray = null;

src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java

@@ -16,7 +16,7 @@
  */
 package org.apache.commons.lang3;
 
-import static org.apache.commons.lang3.ArrayUtils.sort;
+import static org.apache.commons.lang3.ArraySorter.sort;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;

src/test/java/org/apache/commons/lang3/reflect/FieldUtilsTest.java

@@ -34,6 +34,7 @@ import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 
+import org.apache.commons.lang3.ArraySorter;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.JavaVersion;
 import org.apache.commons.lang3.SystemUtils;
@@ -183,7 +184,7 @@ public class FieldUtilsTest {
 
     private Field[] sort(final Field[] fields) {
         // Field does not implement Comparable, so we use a KISS solution here.
-        return ArrayUtils.sort(fields, ObjectToStringComparator.INSTANCE);
+        return ArraySorter.sort(fields, ObjectToStringComparator.INSTANCE);
     }
 
     @Test