ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-04-19 03:01:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

!915 优化ArrayUtil文档注释和部分方法的实现逻辑

Browse Source 
Merge pull request !915 from emptypoint/update-ArrayUtil
This commit is contained in:
Looly 2023-01-11 07:15:39 +00:00 committed by Gitee
commit 8959e029ce
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
1 changed files with 157 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,8 +1,8 @@
package cn.hutool.core.util; package cn.hutool.core.util;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil; import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.collection.UniqueKeySet; import cn.hutool.core.collection.UniqueKeySet;
import cn.hutool.core.collection.iter.IterUtil;
import cn.hutool.core.comparator.CompareUtil; import cn.hutool.core.comparator.CompareUtil;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import cn.hutool.core.exceptions.UtilException; import cn.hutool.core.exceptions.UtilException;
@ -108,10 +108,11 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 是否包含{@code null}元素 * 是否包含{@code null}元素
* <p>如果数组为null，则返回{@code true}，如果数组为空，则返回{@code false}</p>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 被检查的数组 * @param array 被检查的数组
* @return 是否包含{@code null}元素 * @return 是否包含 {@code null} 元素
* @since 3.0.7 * @since 3.0.7
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -127,11 +128,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 多个字段是否全为null * 所有字段是否全为null
* <p>如果数组为{@code null}或者空，则返回 {@code true}</p>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 被检查的数组 * @param array 被检查的数组
* @return 多个字段是否全为null * @return 所有字段是否全为null
* @author dahuoyzs * @author dahuoyzs
* @since 5.4.0 * @since 5.4.0
*/ */
@ -142,11 +144,11 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 是否包含非{@code null}元素<br> * 是否包含非{@code null}元素<br>
* 如果列表是{@code null}或者空，返回{@code false}，否则当列表中有非{@code null}字符时返回{@code true} * <p>如果数组是{@code null}或者空，返回{@code false}，否则当数组中有非{@code null}元素时返回{@code true}</p>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 被检查的数组 * @param array 被检查的数组
* @return 是否包含非{@code null}元素 * @return 是否包含非 {@code null} 元素
* @since 5.4.0 * @since 5.4.0
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -159,7 +161,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
* @return 非空元素，如果不存在非空元素或数组为空，返回{@code null} * @return 第一个非空元素，如果 不存在非空元素 或 数组为空，返回{@code null}
* @since 3.0.7 * @since 3.0.7
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -173,13 +175,13 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param matcher 匹配接口，实现此接口自定义匹配规则 * @param matcher 匹配接口，实现此接口自定义匹配规则
* @param array 数组 * @param array 数组
* @return 匹配元素，如果不存在匹配元素或数组为空，返回 {@code null} * @return 第一个匹配元素，如果 不存在匹配元素 或 数组为空，返回 {@code null}
* @since 3.0.7 * @since 3.0.7
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static <T> T firstMatch(final Predicate<T> matcher, final T... array) { public static <T> T firstMatch(final Predicate<T> matcher, final T... array) {
final int index = matchIndex(matcher, array); final int index = matchIndex(matcher, array);
if (index < 0) { if (index == INDEX_NOT_FOUND) {
return null; return null;
} }
@ -192,7 +194,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param matcher 匹配接口，实现此接口自定义匹配规则 * @param matcher 匹配接口，实现此接口自定义匹配规则
* @param array 数组 * @param array 数组
* @return 匹配到元素的位置，-1表示未匹配到 * @return 第一个匹配元素的位置，{@link #INDEX_NOT_FOUND}表示未匹配到
* @since 5.6.6 * @since 5.6.6
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -205,16 +207,20 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param matcher 匹配接口，实现此接口自定义匹配规则 * @param matcher 匹配接口，实现此接口自定义匹配规则
* @param beginIndexInclude 检索开始的位置 * @param beginIndexInclude 检索开始的位置，不能为负数
* @param array 数组 * @param array 数组
* @return 匹配到元素的位置，-1表示未匹配到 * @return 第一个匹配元素的位置，{@link #INDEX_NOT_FOUND}表示未匹配到
* @since 5.7.3 * @since 5.7.3
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static <T> int matchIndex(final Predicate<T> matcher, final int beginIndexInclude, final T... array) { public static <T> int matchIndex(final Predicate<T> matcher, final int beginIndexInclude, final T... array) {
if (isNotEmpty(array)) { if (isNotEmpty(array)) {
for (int i = beginIndexInclude; i < array.length; i++) { final int length = array.length;
if (null == matcher || matcher.test(array[i])) { if (null == matcher && beginIndexInclude < length) {
return beginIndexInclude;
}
for (int i = beginIndexInclude; i < length; i++) {
if (matcher.test(array[i])) {
return i; return i;
} }
} }
@ -227,7 +233,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* 新建一个空数组 * 新建一个空数组
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param componentType 元素类型 * @param componentType 元素类型，例如：{@code Integer.class}，但是不能使用原始类型，例如：{@code int.class}
* @param newSize 大小 * @param newSize 大小
* @return 空数组 * @return 空数组
*/ */
@ -237,10 +243,10 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 新建一个空数组 * 新建一个{@code Object}类型空数组
* *
* @param newSize 大小 * @param newSize 大小
* @return 空数组 * @return {@code Object}类型的空数组
* @since 3.3.0 * @since 3.3.0
*/ */
public static Object[] newArray(final int newSize) { public static Object[] newArray(final int newSize) {
@ -249,6 +255,14 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 获取数组对象的元素类型 * 获取数组对象的元素类型
* <ul>方法调用参数与返回结果举例：
* <li>Object[] => Object.class</li>
* <li>String[] => String.class</li>
* <li>int[] => int.class</li>
* <li>Integer[] => Integer.class</li>
* <li>null => null</li>
* <li>String => null</li>
* </ul>
* *
* @param array 数组对象 * @param array 数组对象
* @return 元素类型 * @return 元素类型
@ -260,8 +274,16 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 获取数组对象的元素类型 * 获取数组对象的元素类型
* <ul>方法调用参数与返回结果举例：
* <li>Object[].class => Object.class</li>
* <li>String[].class => String.class</li>
* <li>int[].class => int.class</li>
* <li>Integer[].class => Integer.class</li>
* <li>null => null</li>
* <li>String.class => null</li>
* </ul>
* *
* @param arrayClass 数组类 * @param arrayClass 数组对象的class
* @return 元素类型 * @return 元素类型
* @since 3.2.2 * @since 3.2.2
*/ */
@ -272,6 +294,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 根据数组元素类型，获取数组的类型<br> * 根据数组元素类型，获取数组的类型<br>
* 方法是通过创建一个空数组从而获取其类型 * 方法是通过创建一个空数组从而获取其类型
* <p>本方法是 {@link #getComponentType(Class)}的逆方法</p>
* *
* @param componentType 数组元素类型 * @param componentType 数组元素类型
* @return 数组类型 * @return 数组类型
@ -349,11 +372,11 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 将元素值设置为数组的某个位置，当给定的index大于数组长度，则追加 * 将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param buffer 已有数组 * @param buffer 已有数组
* @param index 位置，大于长度追加，否则替换 * @param index 位置，大于等于长度则追加，否则替换
* @param value 新值 * @param value 新值
* @return 新数组或原有数组 * @return 新数组或原有数组
* @since 4.1.2 * @since 4.1.2
@ -373,11 +396,11 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 将元素值设置为数组的某个位置，当给定的index大于数组长度，则追加 * 将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
* *
* @param <A> 数组类型 * @param <A> 数组类型
* @param array 已有数组 * @param array 已有数组
* @param index 位置，大于长度追加，否则替换 * @param index 位置，大于等于长度则追加，否则替换
* @param value 新值 * @param value 新值
* @return 新数组或原有数组 * @return 新数组或原有数组
* @since 4.1.2 * @since 4.1.2
@ -392,13 +415,17 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 将新元素插入到到已有数组中的某个位置<br> * 从数组中的指定位置开始，按顺序使用新元素替换旧元素<br>
* 添加新元素会生成一个新数组或原有数组<br> * <ul>
* 如果插入位置为为负数，那么生成一个由插入元素顺序加已有数组顺序的新数组 * <li>如果 指定位置 为负数，那么生成一个新数组，其中新元素按顺序放在数组头部</li>
* <li>如果 指定位置 大于等于 旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部</li>
* <li>如果 指定位置 加上 新元素数量 大于 旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素</li>
* <li>否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组</li>
* </ul>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param buffer 已有数组 * @param buffer 已有数组
* @param index 位置，大于长度追加，否则替换，&lt;0表示从头部追加 * @param index 位置
* @param values 新值 * @param values 新值
* @return 新数组或原有数组 * @return 新数组或原有数组
* @since 5.7.23 * @since 5.7.23
@ -434,9 +461,9 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 将新元素插入到到已有数组中的某个位置<br> * 将新元素插入到已有数组中的某个位置<br>
* 添加新元素会生成一个新的数组，不影响原数组<br> * 添加新元素会生成一个新的数组，不影响原数组<br>
* 如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充 * 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充<br>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param buffer 已有数组 * @param buffer 已有数组
@ -451,13 +478,13 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 将新元素插入到到已有数组中的某个位置<br> * 将新元素插入到已有数组中的某个位置<br>
* 添加新元素会生成一个新的数组，不影响原数组<br> * 添加新元素会生成一个新的数组，不影响原数组<br>
* 如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充 * 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充<br>
* *
* @param <A> 数组类型 * @param <A> 数组类型
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 已有数组 * @param array 已有数组，可以为原始类型数组
* @param index 插入位置，此位置为对应此位置元素之前的空档 * @param index 插入位置，此位置为对应此位置元素之前的空档
* @param newElements 新元素 * @param newElements 新元素
* @return 新数组 * @return 新数组
@ -495,7 +522,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 生成一个新的重新设置大小的数组<br> * 生成一个新的重新设置大小的数组<br>
* 调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，缩小则截断 * 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断<br>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param data 原数组 * @param data 原数组
@ -517,7 +544,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 生成一个新的重新设置大小的数组<br> * 生成一个新的重新设置大小的数组<br>
* 调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断 * 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断<br>
* *
* @param array 原数组 * @param array 原数组
* @param newSize 新的数组大小 * @param newSize 新的数组大小
@ -543,7 +570,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 生成一个新的重新设置大小的数组<br> * 生成一个新的重新设置大小的数组<br>
* 新数组的类型为原数组的类型，调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，缩小则截断 * 调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断原数组<br>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param buffer 原数组 * @param buffer 原数组
@ -555,7 +582,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 将多个数组合并在一起<br> * 合并所有数组，返回合并后的新数组<br>
* 忽略null的数组 * 忽略null的数组
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
@ -588,7 +615,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 包装 {@link System#arraycopy(Object, int, Object, int, int)}<br> * 包装 {@link System#arraycopy(Object, int, Object, int, int)}<br>
* 数组复制，缘数组和目标数组都是从位置0开始复制，复制长度为源数组的长度 * 数组复制，源数组和目标数组都是从位置0开始复制，复制长度为源数组的长度<br>
* *
* @param <T> 目标数组类型 * @param <T> 目标数组类型
* @param src 源数组 * @param src 源数组
@ -601,7 +628,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 包装 {@link System#arraycopy(Object, int, Object, int, int)}<br> * 包装 {@link System#arraycopy(Object, int, Object, int, int)}<br>
* 数组复制，缘数组和目标数组都是从位置0开始复制 * 数组复制，源数组和目标数组都是从位置0开始复制<br>
* *
* @param <T> 目标数组类型 * @param <T> 目标数组类型
* @param src 源数组 * @param src 源数组
@ -662,7 +689,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
if (isArray(obj)) { if (isArray(obj)) {
final Object result; final Object result;
final Class<?> componentType = obj.getClass().getComponentType(); final Class<?> componentType = obj.getClass().getComponentType();
if (componentType.isPrimitive()) {// 原始类型 // 原始类型
if (componentType.isPrimitive()) {
int length = Array.getLength(obj); int length = Array.getLength(obj);
result = Array.newInstance(componentType, length); result = Array.newInstance(componentType, length);
while (length-- > 0) { while (length-- > 0) {
@ -677,27 +705,25 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 编辑数组<br> * 对每个数组元素执行指定操作，返回操作后的元素<br>
* 编辑过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能： * 这个Editor实现可以实现以下功能：
* * <ol>
* <pre> * <li>过滤出需要的对象，如果返回{@code null}则抛弃这个元素对象</li>
* 1、过滤出需要的对象，如果返回{@code null}表示这个元素对象抛弃 * <li>修改元素对象，返回修改后的对象</li>
* 2、修改元素对象，返回集合中为修改后的对象 * </ol>
* </pre>
* <p>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
* @param editor 编辑器接口，{@code null}返回原集合 * @param editor 编辑器接口，为 {@code null}则返回原数组
* @return 编辑后的数组 * @return 编辑后的数组
* @since 5.3.3 * @since 5.3.3
*/ */
public static <T> T[] edit(final T[] array, final UnaryOperator<T> editor) { public static <T> T[] edit(final T[] array, final UnaryOperator<T> editor) {
if (null == editor) { if (null == array || null == editor) {
return array; return array;
} }
final ArrayList<T> list = new ArrayList<>(array.length); final List<T> list = new ArrayList<>(array.length);
T modified; T modified;
for (final T t : array) { for (final T t : array) {
modified = editor.apply(t); modified = editor.apply(t);
@ -710,16 +736,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 过滤<br> * 过滤数组元素<br>
* 过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能： * 保留 {@link Predicate#test(Object)}为{@code true}的元素
*
* <pre>
* 1、过滤出需要的对象，{@link Predicate#test(Object)}为{@code true}对象将被加入结果集合中
* </pre>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
* @param predicate 过滤器接口，用于定义过滤规则，{@link Predicate#test(Object)}为{@code true}保留，{@code null}返回原集合 * @param predicate 过滤器接口，用于定义过滤规则，为{@code null}则返回原数组
* @return 过滤后的数组 * @return 过滤后的数组
* @since 3.2.1 * @since 3.2.1
*/ */
@ -731,7 +753,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 去除{@code null} 元素 * 去除 {@code null} 元素
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
@ -739,10 +761,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 3.2.2 * @since 3.2.2
*/ */
public static <T> T[] removeNull(final T[] array) { public static <T> T[] removeNull(final T[] array) {
return edit(array, t -> { // 返回元素本身，如果为null便自动过滤
// 返回null便不加入集合 return edit(array, UnaryOperator.identity());
return t;
});
} }
/** /**
@ -773,7 +793,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* 数组元素中的null转换为"" * 数组元素中的null转换为""
* *
* @param array 数组 * @param array 数组
* @return 新数组 * @return 处理后的数组
* @since 3.2.1 * @since 3.2.1
*/ */
public static String[] nullToEmpty(final String[] array) { public static String[] nullToEmpty(final String[] array) {
@ -792,13 +812,13 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @param <V> Value类型 * @param <V> Value类型
* @param keys 键列表 * @param keys 键列表
* @param values 值列表 * @param values 值列表
* @param isOrder 是否有序 * @param isOrder Map中的元素是否保留键值数组本身的顺序
* @return Map * @return Map
* @since 3.0.4 * @since 3.0.4
*/ */
public static <K, V> Map<K, V> zip(final K[] keys, final V[] values, final boolean isOrder) { public static <K, V> Map<K, V> zip(final K[] keys, final V[] values, final boolean isOrder) {
if (isEmpty(keys) || isEmpty(values)) { if (isEmpty(keys) || isEmpty(values)) {
return null; return MapUtil.newHashMap(0, isOrder);
} }
final int size = Math.min(keys.length, values.length); final int size = Math.min(keys.length, values.length);
@ -866,7 +886,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 3.1.2 * @since 3.1.2
*/ */
public static int indexOfIgnoreCase(final CharSequence[] array, final CharSequence value) { public static int indexOfIgnoreCase(final CharSequence[] array, final CharSequence value) {
if (null != array) { if (isNotEmpty(array)) {
for (int i = 0; i < array.length; i++) { for (int i = 0; i < array.length; i++) {
if (StrUtil.equalsIgnoreCase(array[i], value)) { if (StrUtil.equalsIgnoreCase(array[i], value)) {
return i; return i;
@ -877,12 +897,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND} * 返回数组中指定元素最后的所在位置，未找到返回{@link #INDEX_NOT_FOUND}
* *
* @param <T> 数组类型 * @param <T> 数组类型
* @param array 数组 * @param array 数组
* @param value 被检查的元素 * @param value 被检查的元素
* @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND} * @return 数组中指定元素最后的所在位置，未找到返回{@link #INDEX_NOT_FOUND}
* @since 3.0.7 * @since 3.0.7
*/ */
public static <T> int lastIndexOf(final T[] array, final Object value) { public static <T> int lastIndexOf(final T[] array, final Object value) {
@ -893,13 +913,13 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 返回数组中指定元素所在最后的位置，未找到返回{@link #INDEX_NOT_FOUND} * 返回数组中指定元素最后的所在位置，未找到返回{@link #INDEX_NOT_FOUND}
* *
* @param <T> 数组类型 * @param <T> 数组类型
* @param array 数组 * @param array 数组
* @param value 被检查的元素 * @param value 被检查的元素
* @param endInclude 查找方式为从后向前查找，查找的数组结束位置，一般为array.length-1 * @param endInclude 从后向前查找时的起始位置，一般为{@code array.length - 1}
* @return 数组中指定元素所在位置，未找到返回{@link #INDEX_NOT_FOUND} * @return 数组中指定元素最后的所在位置，未找到返回{@link #INDEX_NOT_FOUND}
* @since 5.7.3 * @since 5.7.3
*/ */
public static <T> int lastIndexOf(final T[] array, final Object value, final int endInclude) { public static <T> int lastIndexOf(final T[] array, final Object value, final int endInclude) {
@ -914,7 +934,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 数组中是否包含元素 * 数组中是否包含指定元素
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
@ -945,12 +965,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 数组中是否包含指定元素中的全部 * 数组中是否包含所有指定元素
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
* @param values 被检查的多个元素 * @param values 被检查的多个元素
* @return 是否包含指定元素中的全部 * @return 是否包含所有指定元素
* @since 5.4.7 * @since 5.4.7
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -990,8 +1010,6 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
if (isArray(obj)) { if (isArray(obj)) {
try { try {
return (Object[]) obj;
} catch (final Exception e) {
final String className = obj.getClass().getComponentType().getName(); final String className = obj.getClass().getComponentType().getName();
switch (className) { switch (className) {
case "long": case "long":
@ -1011,8 +1029,10 @@ public class ArrayUtil extends PrimitiveArrayUtil {
case "double": case "double":
return wrap((double[]) obj); return wrap((double[]) obj);
default: default:
throw new UtilException(e); return (Object[]) obj;
} }
} catch (final Exception e) {
throw new UtilException(e);
} }
} }
throw new UtilException(StrUtil.format("[{}] is not Array!", obj.getClass())); throw new UtilException(StrUtil.format("[{}] is not Array!", obj.getClass()));
@ -1054,12 +1074,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 获取数组中指定多个下标元素值，组成新数组 * 获取数组中所有指定位置的元素值，组成新数组
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组，如果提供为{@code null}则返回{@code null} * @param array 数组，如果提供为{@code null}则返回{@code null}
* @param indexes 下标列表 * @param indexes 下标列表
* @return 结果 * @return 指定位置的元素值数组
*/ */
public static <T> T[] getAny(final Object array, final int... indexes) { public static <T> T[] getAny(final Object array, final int... indexes) {
if (null == array) { if (null == array) {
@ -1095,18 +1115,15 @@ public class ArrayUtil extends PrimitiveArrayUtil {
if (end < 0) { if (end < 0) {
end += length; end += length;
} }
if (start == length) {
return newArray(array.getClass().getComponentType(), 0);
}
if (start > end) { if (start > end) {
final int tmp = start; final int tmp = start;
start = end; start = end;
end = tmp; end = tmp;
} }
if (end > length) {
if (start >= length) { if (start >= length) {
return newArray(array.getClass().getComponentType(), 0); return newArray(array.getClass().getComponentType(), 0);
} }
if (end > length) {
end = length; end = length;
} }
return Arrays.copyOfRange(array, start, end); return Arrays.copyOfRange(array, start, end);
@ -1143,18 +1160,15 @@ public class ArrayUtil extends PrimitiveArrayUtil {
if (end < 0) { if (end < 0) {
end += length; end += length;
} }
if (start == length) {
return new Object[0];
}
if (start > end) { if (start > end) {
final int tmp = start; final int tmp = start;
start = end; start = end;
end = tmp; end = tmp;
} }
if (end > length) {
if (start >= length) { if (start >= length) {
return new Object[0]; return new Object[0];
} }
if (end > length) {
end = length; end = length;
} }
@ -1162,7 +1176,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
step = 1; step = 1;
} }
final ArrayList<Object> list = new ArrayList<>(); final List<Object> list = new ArrayList<>();
for (int i = start; i < end; i += step) { for (int i = start; i < end; i += step) {
list.add(get(array, i)); list.add(get(array, i));
} }
@ -1238,7 +1252,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 以 conjunction 为分隔符将数组转换为字符串 * 以 conjunction 为分隔符将数组转换为字符串
* *
* @param <T> 被处理的集合 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
* @param conjunction 分隔符 * @param conjunction 分隔符
* @return 连接后的字符串 * @return 连接后的字符串
@ -1250,7 +1264,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 以 conjunction 为分隔符将数组转换为字符串 * 以 conjunction 为分隔符将数组转换为字符串
* *
* @param <T> 被处理的集合 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
* @param delimiter 分隔符 * @param delimiter 分隔符
* @param prefix 每个元素添加的前缀，null表示不添加 * @param prefix 每个元素添加的前缀，null表示不添加
@ -1271,9 +1285,9 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 以 conjunction 为分隔符将数组转换为字符串 * 先处理数组元素，再以 conjunction 为分隔符将数组转换为字符串
* *
* @param <T> 被处理的集合 * @param <T> 数组元素类型
* @param array 数组 * @param array 数组
* @param conjunction 分隔符 * @param conjunction 分隔符
* @param editor 每个元素的编辑器，null表示不编辑 * @param editor 每个元素的编辑器，null表示不编辑
@ -1281,7 +1295,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 5.3.3 * @since 5.3.3
*/ */
public static <T> String join(final T[] array, final CharSequence conjunction, final UnaryOperator<T> editor) { public static <T> String join(final T[] array, final CharSequence conjunction, final UnaryOperator<T> editor) {
return StrJoiner.of(conjunction).append(array, (t) -> String.valueOf(editor.apply(t))).toString(); return StrJoiner.of(conjunction).append(edit(array, editor)).toString();
} }
/** /**
@ -1333,7 +1347,10 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 3.0.9 * @since 3.0.9
*/ */
public static <T> T[] toArray(final Iterator<T> iterator, final Class<T> componentType) { public static <T> T[] toArray(final Iterator<T> iterator, final Class<T> componentType) {
return toArray(ListUtil.of(iterator), componentType); if (null == iterator) {
return newArray(componentType, 0);
}
return ListUtil.of(iterator).toArray(newArray(componentType, 0));
} }
/** /**
@ -1346,7 +1363,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 3.0.9 * @since 3.0.9
*/ */
public static <T> T[] toArray(final Iterable<T> iterable, final Class<T> componentType) { public static <T> T[] toArray(final Iterable<T> iterable, final Class<T> componentType) {
return CollUtil.toCollection(iterable).toArray(newArray(componentType, 0)); return toArray(IterUtil.getIter(iterable), componentType);
} }
// ---------------------------------------------------------------------- remove // ---------------------------------------------------------------------- remove
@ -1370,7 +1387,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 移除数组中指定的元素<br> * 移除数组中指定的元素<br>
* 只会移除匹配到的第一个元素 copy from commons-lang * 只会移除匹配到的第一个元素<br>
* copy from commons-lang<br>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 数组对象，可以是对象数组，也可以原始类型数组 * @param array 数组对象，可以是对象数组，也可以原始类型数组
@ -1574,7 +1592,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* 计算{@code null}或空元素对象的个数，通过{@link ObjUtil#isEmpty(Object)} 判断元素 * 计算{@code null}或空元素对象的个数，通过{@link ObjUtil#isEmpty(Object)} 判断元素
* *
* @param args 被检查的对象,一个或者多个 * @param args 被检查的对象,一个或者多个
* @return 存在{@code null}的数量 * @return {@code null}或空元素对象的个数
* @since 4.5.18 * @since 4.5.18
*/ */
public static int emptyCount(final Object... args) { public static int emptyCount(final Object... args) {
@ -1591,11 +1609,11 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 是否存在{@code null}或空对象，通过{@link ObjUtil#isEmpty(Object)} 判断元素<br> * 是否存在{@code null}或空对象，通过{@link ObjUtil#isEmpty(Object)} 判断元素<br>
* 如果提供数组本身为空， * <p>如果提供的数组本身为空，则返回{@code false}</p>
* *
* @param <T> 元素类型 * @param <T> 元素类型
* @param args 被检查对象 * @param args 被检查对象
* @return 是否存在 * @return 是否存在 {@code null} 或空对象
* @since 4.5.18 * @since 4.5.18
*/ */
public static <T> boolean hasEmpty(final T[] args) { public static <T> boolean hasEmpty(final T[] args) {
@ -1610,7 +1628,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 是否存都为{@code null}或空对象，通过{@link ObjUtil#isEmpty(Object)} 判断元素 * 是否所有元素都为{@code null}或空对象，通过{@link ObjUtil#isEmpty(Object)} 判断元素
* <p>如果提供的数组本身为空，则返回{@code true}</p>
* *
* @param <T> 元素类型 * @param <T> 元素类型
* @param args 被检查的对象,一个或者多个 * @param args 被检查的对象,一个或者多个
@ -1627,7 +1646,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 是否存都不为{@code null}或空对象，通过{@link ObjUtil#isEmpty(Object)} 判断元素 * 是否所有元素都不为{@code null}或空对象，通过{@link ObjUtil#isEmpty(Object)} 判断元素
* <p>如果提供的数组本身为空，则返回{@code true}</p>
* *
* @param args 被检查的对象,一个或者多个 * @param args 被检查的对象,一个或者多个
* @return 是否都不为空 * @return 是否都不为空
@ -1638,11 +1658,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 多个字段是否全部不为null * 是否所有元素都不为 {@code null}
* <p>如果提供的数组为null，则返回{@code false}，如果提供的数组为空，则返回{@code true}</p>
* *
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @param array 被检查的数组 * @param array 被检查的数组
* @return 多个字段是否全部不为null * @return 是否所有元素都不为 {@code null}
* @since 5.4.0 * @since 5.4.0
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -1710,8 +1731,9 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 5.4.2 * @since 5.4.2
*/ */
public static <T, R> R[] map(final T[] array, final Class<R> targetComponentType, final Function<? super T, ? extends R> func) { public static <T, R> R[] map(final T[] array, final Class<R> targetComponentType, final Function<? super T, ? extends R> func) {
final R[] result = newArray(targetComponentType, array.length); final int length = length(array);
for (int i = 0; i < array.length; i++) { final R[] result = newArray(targetComponentType, length);
for (int i = 0; i < length; i++) {
result[i] = func.apply(array[i]); result[i] = func.apply(array[i]);
} }
return result; return result;
@ -1738,13 +1760,13 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 按照指定规则，将一种类型的数组元素提取后转换为{@link List} * 按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 {@link List}
* *
* @param array 被转换的数组 * @param array 被转换的数组
* @param func 转换规则函数 * @param func 转换规则函数
* @param <T> 原数组类型 * @param <T> 原数组类型
* @param <R> 目标数组类型 * @param <R> 目标数组类型
* @return 转换后的数组 * @return 列表
* @since 5.5.7 * @since 5.5.7
*/ */
public static <T, R> List<R> map(final T[] array, final Function<? super T, ? extends R> func) { public static <T, R> List<R> map(final T[] array, final Function<? super T, ? extends R> func) {
@ -1752,13 +1774,13 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 按照指定规则，将一种类型的数组元素提取后转换为{@link Set} * 按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 {@link Set}
* *
* @param array 被转换的数组 * @param array 被转换的数组
* @param func 转换规则函数 * @param func 转换规则函数
* @param <T> 原数组类型 * @param <T> 原数组类型
* @param <R> 目标数组类型 * @param <R> 目标数组类型
* @return 转换后的数组 * @return 集合
* @since 5.8.0 * @since 5.8.0
*/ */
public static <T, R> Set<R> mapToSet(final T[] array, final Function<? super T, ? extends R> func) { public static <T, R> Set<R> mapToSet(final T[] array, final Function<? super T, ? extends R> func) {
@ -1807,12 +1829,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 查找子数组的位置 * 是否是数组的子数组
* *
* @param array 数组 * @param array 数组
* @param subArray 子数组 * @param subArray 子数组
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @return 子数组的开始位置，即子数字第一个元素在数组中的位置 * @return 是否是数组的子数组
* @since 5.4.8 * @since 5.4.8
*/ */
public static <T> boolean isSub(final T[] array, final T[] subArray) { public static <T> boolean isSub(final T[] array, final T[] subArray) {
@ -1880,10 +1902,10 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* 查找最后一个子数组的开始位置 * 查找最后一个子数组的开始位置
* *
* @param array 数组 * @param array 数组
* @param endInclude 查找结束的位置（包含） * @param endInclude 从后往前查找时的开始位置（包含）
* @param subArray 子数组 * @param subArray 子数组
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @return 最后一个子数组的开始位置，即子数字第一个元素在数组中的位置 * @return 最后一个子数组的开始位置，即从后往前，子数字第一个元素在数组中的位置
* @since 5.4.8 * @since 5.4.8
*/ */
public static <T> int lastIndexOfSub(final T[] array, final int endInclude, final T[] subArray) { public static <T> int lastIndexOfSub(final T[] array, final int endInclude, final T[] subArray) {
@ -1891,7 +1913,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
return INDEX_NOT_FOUND; return INDEX_NOT_FOUND;
} }
final int firstIndex = lastIndexOf(array, subArray[0]); final int firstIndex = lastIndexOf(array, subArray[0], endInclude);
if (firstIndex < 0 || firstIndex + subArray.length > array.length) { if (firstIndex < 0 || firstIndex + subArray.length > array.length) {
return INDEX_NOT_FOUND; return INDEX_NOT_FOUND;
} }
@ -1908,21 +1930,22 @@ public class ArrayUtil extends PrimitiveArrayUtil {
// O(n)时间复杂度检查数组是否有序 // O(n)时间复杂度检查数组是否有序
/** /**
* 检查数组是否有序，即comparator.compare(array[i], array[i + 1]) &lt;= 0，若传入空数组或空比较器，则返回false * 检查数组是否按升序排列，即 {@code comparator.compare(array[i], array[i + 1]) <= 0}
* <p>若传入空数组或空比较器，则返回{@code false}</p>
* *
* @param array 数组 * @param array 数组
* @param comparator 比较器 * @param comparator 比较器
* @param <T> 数组元素类型 * @param <T> 数组元素类型
* @return 数组是否有序 * @return 数组是否升序
* @author FengBaoheng * @since 6.0.0
* @since 5.5.2
*/ */
public static <T> boolean isSorted(final T[] array, final Comparator<? super T> comparator) { public static <T> boolean isSorted(final T[] array, final Comparator<? super T> comparator) {
if (array == null || comparator == null) { if (array == null || comparator == null) {
return false; return false;
} }
for (int i = 0; i < array.length - 1; i++) { final int size = array.length - 1;
for (int i = 0; i < size; i++) {
if (comparator.compare(array[i], array[i + 1]) > 0) { if (comparator.compare(array[i], array[i + 1]) > 0) {
return false; return false;
} }
@ -1931,7 +1954,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 检查数组是否升序，即array[i].compareTo(array[i + 1]) &lt;= 0，若传入空数组，则返回false * 检查数组是否升序，即 {@code array[i].compareTo(array[i + 1]) <= 0}
* <p>若传入空数组，则返回{@code false}</p>
* *
* @param <T> 数组元素类型，该类型需要实现Comparable接口 * @param <T> 数组元素类型，该类型需要实现Comparable接口
* @param array 数组 * @param array 数组
@ -1945,7 +1969,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
/** /**
* 检查数组是否升序，即array[i].compareTo(array[i + 1]) &lt;= 0，若传入空数组，则返回false * 检查数组是否升序，即 {@code array[i].compareTo(array[i + 1]) <= 0}
* <p>若传入空数组，则返回{@code false}</p>
* *
* @param <T> 数组元素类型，该类型需要实现Comparable接口 * @param <T> 数组元素类型，该类型需要实现Comparable接口
* @param array 数组 * @param array 数组
@ -1954,11 +1979,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 5.5.2 * @since 5.5.2
*/ */
public static <T extends Comparable<? super T>> boolean isSortedASC(final T[] array) { public static <T extends Comparable<? super T>> boolean isSortedASC(final T[] array) {
if (array == null) { if (isEmpty(array)) {
return false; return false;
} }
for (int i = 0; i < array.length - 1; i++) { final int size = array.length - 1;
for (int i = 0; i < size; i++) {
if (array[i].compareTo(array[i + 1]) > 0) { if (array[i].compareTo(array[i + 1]) > 0) {
return false; return false;
} }
@ -1968,7 +1994,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
} }
/** /**
* 检查数组是否降序，即array[i].compareTo(array[i + 1]) &gt;= 0，若传入空数组，则返回false * 检查数组是否降序，即 {@code array[i].compareTo(array[i + 1]) >= 0}
* <p>若传入空数组，则返回{@code false}</p>
* *
* @param <T> 数组元素类型，该类型需要实现Comparable接口 * @param <T> 数组元素类型，该类型需要实现Comparable接口
* @param array 数组 * @param array 数组
@ -1977,11 +2004,12 @@ public class ArrayUtil extends PrimitiveArrayUtil {
* @since 5.5.2 * @since 5.5.2
*/ */
public static <T extends Comparable<? super T>> boolean isSortedDESC(final T[] array) { public static <T extends Comparable<? super T>> boolean isSortedDESC(final T[] array) {
if (array == null) { if (isEmpty(array)) {
return false; return false;
} }
for (int i = 0; i < array.length - 1; i++) { final int size = array.length - 1;
for (int i = 0; i < size; i++) {
if (array[i].compareTo(array[i + 1]) < 0) { if (array[i].compareTo(array[i + 1]) < 0) {
return false; return false;
} }