add isSort

CHANGELOG.md

@@ -29,6 +29,7 @@
 * 【core   】     ZipUtil增加Zip方法（pr#222@Gitee）
 * 【all    】     增加Hutool.getAllUtils和printAllUtils方法
 * 【core   】     增加PunyCode（issue#1268@Gitee）
+* 【core   】     ArrayUtil增加isSorted方法（pr#1271@Github）
 
 ### Bug修复
 * 【cron   】     修复CronTimer可能死循环的问题（issue#1224@Github）

hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java

@@ -30,7 +30,7 @@ import java.util.function.Function;
  *
  * @author Looly
  */
-public class ArrayUtil extends PrimitiveArrayUtil{
+public class ArrayUtil extends PrimitiveArrayUtil {
 
 	// ---------------------------------------------------------------------- isEmpty
 
@@ -1765,398 +1765,6 @@ public class ArrayUtil extends PrimitiveArrayUtil{
 	// O(n)时间复杂度检查数组是否有序
 
 	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSorted(byte[] array) {
-		return isSortedASC(array);
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedASC(byte[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] > array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否降序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedDESC(byte[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] < array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSorted(short[] array) {
-		return isSortedASC(array);
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedASC(short[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] > array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否降序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedDESC(short[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] < array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSorted(char[] array) {
-		return isSortedASC(array);
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedASC(char[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] > array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否降序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedDESC(char[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] < array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSorted(int[] array) {
-		return isSortedASC(array);
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedASC(int[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] > array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否降序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedDESC(int[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] < array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSorted(long[] array) {
-		return isSortedASC(array);
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedASC(long[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] > array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否降序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedDESC(long[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] < array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSorted(double[] array) {
-		return isSortedASC(array);
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedASC(double[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] > array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否降序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedDESC(double[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] < array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSorted(float[] array) {
-		return isSortedASC(array);
-	}
-
-	/**
-	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否升序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedASC(float[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] > array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
-	 *
-	 * @param array 数组
-	 * @return 数组是否降序
-	 * @author FengBaoheng
-	 * @since 5.5.2
-	 */
-	public static boolean isSortedDESC(float[] array) {
-		if (array == null) {
-			return false;
-		}
-
-		for (int i = 0; i < array.length - 1; i++) {
-			if (array[i] < array[i + 1]) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
 	 * 检查数组是否有序，即comparator.compare(array[i], array[i + 1]) <= 0，若传入空数组或空比较器，则返回false
 	 *
 	 * @param array      数组

hutool-core/src/main/java/cn/hutool/core/util/PrimitiveArrayUtil.java

@@ -3003,4 +3003,396 @@ public class PrimitiveArrayUtil {
 		array[index2] = tmp;
 		return array;
 	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSorted(byte[] array) {
+		return isSortedASC(array);
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedASC(byte[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] > array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否降序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedDESC(byte[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] < array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSorted(short[] array) {
+		return isSortedASC(array);
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedASC(short[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] > array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否降序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedDESC(short[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] < array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSorted(char[] array) {
+		return isSortedASC(array);
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedASC(char[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] > array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否降序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedDESC(char[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] < array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSorted(int[] array) {
+		return isSortedASC(array);
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedASC(int[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] > array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否降序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedDESC(int[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] < array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSorted(long[] array) {
+		return isSortedASC(array);
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedASC(long[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] > array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否降序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedDESC(long[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] < array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSorted(double[] array) {
+		return isSortedASC(array);
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedASC(double[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] > array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否降序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedDESC(double[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] < array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSorted(float[] array) {
+		return isSortedASC(array);
+	}
+
+	/**
+	 * 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否升序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedASC(float[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] > array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
+	 *
+	 * @param array 数组
+	 * @return 数组是否降序
+	 * @author FengBaoheng
+	 * @since 5.5.2
+	 */
+	public static boolean isSortedDESC(float[] array) {
+		if (array == null) {
+			return false;
+		}
+
+		for (int i = 0; i < array.length - 1; i++) {
+			if (array[i] < array[i + 1]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
 }