plusone/plusone-commons
1
1
Fork 1
Code Issues Pull Requests Projects Releases 5 Activity

refactor(util): ArrayTools 中的 isNullOrEmpty 重命名为 isEmpty

Browse Source 
保持方法命名的一致性

BREAKING CHANGE: `ArrayTools#isNullOrEmpty` 重命名为 `ArrayTools#isEmpty`
This commit is contained in:
zhouxy108 2025-04-29 11:26:12 +08:00
parent 45dc105dd0
commit ee7213a687
4 changed files with 51 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java
View File

@ -54,9 +54,9 @@ public class ArrayTools {
public static final int NOT_FOUND_INDEX = -1; public static final int NOT_FOUND_INDEX = -1;
// #region - isNullOrEmpty // #region - isEmpty
// isNullOrEmpty // isEmpty
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
@ -65,84 +65,84 @@ public class ArrayTools {
* @param <T> 数组中元素的类型 * @param <T> 数组中元素的类型
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static <T> boolean isNullOrEmpty(@Nullable T[] arr) { public static <T> boolean isEmpty(@Nullable T[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }
// isNullOrEmpty - char // isEmpty - char
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
* *
* @param arr 待检查的数组，可以为 {@code null} * @param arr 待检查的数组，可以为 {@code null}
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static boolean isNullOrEmpty(@Nullable char[] arr) { public static boolean isEmpty(@Nullable char[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }
// isNullOrEmpty - byte // isEmpty - byte
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
* *
* @param arr 待检查的数组，可以为 {@code null} * @param arr 待检查的数组，可以为 {@code null}
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static boolean isNullOrEmpty(@Nullable byte[] arr) { public static boolean isEmpty(@Nullable byte[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }
// isNullOrEmpty - short // isEmpty - short
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
* *
* @param arr 待检查的数组，可以为 {@code null} * @param arr 待检查的数组，可以为 {@code null}
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static boolean isNullOrEmpty(@Nullable short[] arr) { public static boolean isEmpty(@Nullable short[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }
// isNullOrEmpty - int // isEmpty - int
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
* *
* @param arr 待检查的数组，可以为 {@code null} * @param arr 待检查的数组，可以为 {@code null}
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static boolean isNullOrEmpty(@Nullable int[] arr) { public static boolean isEmpty(@Nullable int[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }
// isNullOrEmpty - long // isEmpty - long
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
* *
* @param arr 待检查的数组，可以为 {@code null} * @param arr 待检查的数组，可以为 {@code null}
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static boolean isNullOrEmpty(@Nullable long[] arr) { public static boolean isEmpty(@Nullable long[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }
// isNullOrEmpty - float // isEmpty - float
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
* *
* @param arr 待检查的数组，可以为 {@code null} * @param arr 待检查的数组，可以为 {@code null}
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static boolean isNullOrEmpty(@Nullable float[] arr) { public static boolean isEmpty(@Nullable float[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }
// isNullOrEmpty - double // isEmpty - double
/** /**
* 检查给定数组是否为空 * 检查给定数组是否为空
* *
* @param arr 待检查的数组，可以为 {@code null} * @param arr 待检查的数组，可以为 {@code null}
* @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false} * @return 如果数组为 {@code null} 或长度为 0，则返回 {@code true}；否则返回 {@code false}
*/ */
public static boolean isNullOrEmpty(@Nullable double[] arr) { public static boolean isEmpty(@Nullable double[] arr) {
return arr == null || arr.length == 0; return arr == null || arr.length == 0;
} }

2
src/main/java/xyz/zhouxy/plusone/commons/util/BigDecimals.java
View File

@ -105,7 +105,7 @@ public class BigDecimals {
* @return 求和结果 * @return 求和结果
*/ */
public static BigDecimal sum(final BigDecimal... numbers) { public static BigDecimal sum(final BigDecimal... numbers) {
if (ArrayTools.isNullOrEmpty(numbers)) { if (ArrayTools.isEmpty(numbers)) {
return BigDecimal.ZERO; return BigDecimal.ZERO;
} }
BigDecimal result = BigDecimals.nullToZero(numbers[0]); BigDecimal result = BigDecimals.nullToZero(numbers[0]);

2
src/main/java/xyz/zhouxy/plusone/commons/util/Numbers.java
View File

@ -108,7 +108,7 @@ public class Numbers {
* @return 求和结果 * @return 求和结果
*/ */
public static BigInteger sum(final BigInteger... numbers) { public static BigInteger sum(final BigInteger... numbers) {
if (ArrayTools.isNullOrEmpty(numbers)) { if (ArrayTools.isEmpty(numbers)) {
return BigInteger.ZERO; return BigInteger.ZERO;
} }
BigInteger result = Numbers.nullToZero(numbers[0]); BigInteger result = Numbers.nullToZero(numbers[0]);

64
src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java
View File

@ -57,53 +57,53 @@ public class ArrayToolsTests {
static final double[] EMPTY_DOUBLE_ARRAY = {}; static final double[] EMPTY_DOUBLE_ARRAY = {};
// ================================ // ================================
// #region - isNullOrEmpty // #region - isEmpty
// ================================ // ================================
@Test @Test
void isNullOrEmpty_NullArray_ReturnsTrue() { void isEmpty_NullArray_ReturnsTrue() {
assertAll( assertAll(
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_STRING_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_STRING_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_INTEGER_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_INTEGER_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_CHAR_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_CHAR_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_BYTE_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_BYTE_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_SHORT_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_SHORT_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_INT_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_INT_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_LONG_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_LONG_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_FLOAT_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(NULL_FLOAT_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(NULL_DOUBLE_ARRAY))); () -> assertTrue(ArrayTools.isEmpty(NULL_DOUBLE_ARRAY)));
} }
@Test @Test
void isNullOrEmpty_EmptyArray_ReturnsTrue() { void isEmpty_EmptyArray_ReturnsTrue() {
assertAll( assertAll(
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_STRING_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_STRING_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_INTEGER_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_INTEGER_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_CHAR_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_CHAR_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_BYTE_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_BYTE_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_SHORT_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_SHORT_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_INT_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_INT_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_LONG_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_LONG_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_FLOAT_ARRAY)), () -> assertTrue(ArrayTools.isEmpty(EMPTY_FLOAT_ARRAY)),
() -> assertTrue(ArrayTools.isNullOrEmpty(EMPTY_DOUBLE_ARRAY))); () -> assertTrue(ArrayTools.isEmpty(EMPTY_DOUBLE_ARRAY)));
} }
@Test @Test
void isNullOrEmpty_NonEmptyArray_ReturnsFalse() { void isEmpty_NonEmptyArray_ReturnsFalse() {
assertAll( assertAll(
() -> assertFalse(ArrayTools.isNullOrEmpty(new String[] { "a" })), () -> assertFalse(ArrayTools.isEmpty(new String[] { "a" })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new Integer[] { 1 })), () -> assertFalse(ArrayTools.isEmpty(new Integer[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new char[] { 'a' })), () -> assertFalse(ArrayTools.isEmpty(new char[] { 'a' })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new byte[] { 1 })), () -> assertFalse(ArrayTools.isEmpty(new byte[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new short[] { 1 })), () -> assertFalse(ArrayTools.isEmpty(new short[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new int[] { 1 })), () -> assertFalse(ArrayTools.isEmpty(new int[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new long[] { 1 })), () -> assertFalse(ArrayTools.isEmpty(new long[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new float[] { 1 })), () -> assertFalse(ArrayTools.isEmpty(new float[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new double[] { 1 }))); () -> assertFalse(ArrayTools.isEmpty(new double[] { 1 })));
} }
// ================================ // ================================
// #endregion - isNullOrEmpty // #endregion - isEmpty
// ================================ // ================================
// ================================ // ================================