lsm/hutool
1
0
Fork 0
mirror of https://gitee.com/dromara/hutool.git synced 2025-04-05 17:37:59 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

add isSort

Browse Source
This commit is contained in:
Looly 2020-12-01 15:50:07 +08:00
parent b374a943ff
commit 12711ba6fa
3 changed files with 394 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -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）

394
hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
View File

@ -30,7 +30,7 @@ import java.util.function.Function;
*
* @author Looly
*/
public class ArrayUtil extends PrimitiveArrayUtil{
public class ArrayUtil extends PrimitiveArrayUtil {
// ---------------------------------------------------------------------- isEmpty
@ -1764,398 +1764,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
*

392
hutool-core/src/main/java/cn/hutool/core/util/PrimitiveArrayUtil.java
View File

@ -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;
}
}