dev.utils.common.CollectionUtils Maven / Gradle / Ivy
package dev.utils.common;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import dev.utils.JCLogUtils;
/**
* detail: 集合工具类 ( Collection - List、Set、Queue ) 等
* @author Ttt
*
* // 升序
* Collections.sort(list);
* // 降序
* Collections.sort(list, Collections.reverseOrder());
* // 逆序
* Collections.reverse(list);
* // 创建不可修改集合
* Collections.unmodifiableList()
* Arrays.asList()
*
*/
public final class CollectionUtils {
private CollectionUtils() {
}
// 日志 TAG
private static final String TAG = CollectionUtils.class.getSimpleName();
// ==============
// = Collection =
// ==============
/**
* 判断 Collection 是否为 null
* @param collection {@link Collection}
* @return {@code true} yes, {@code false} no
*/
public static boolean isEmpty(final Collection collection) {
return (collection == null || collection.isEmpty());
}
/**
* 判断 Collection 是否不为 null
* @param collection {@link Collection}
* @return {@code true} yes, {@code false} no
*/
public static boolean isNotEmpty(final Collection collection) {
return (collection != null && !collection.isEmpty());
}
// ==========
// = 判断长度 =
// ==========
/**
* 获取 Collection 长度
* @param collection {@link Collection}
* @return 如果 Collection 为 null, 则返回默认长度, 如果不为 null, 则返回 collection.size()
*/
public static int length(final Collection collection) {
return length(collection, 0);
}
/**
* 获取 Collection 长度
* @param collection {@link Collection}
* @param defaultLength 集合为 null 默认长度
* @return 如果 Collection 为 null, 则返回 defaultLength, 如果不为 null, 则返回 collection.size()
*/
public static int length(
final Collection collection,
final int defaultLength
) {
return collection != null ? collection.size() : defaultLength;
}
// =
/**
* 获取长度 Collection 是否等于期望长度
* @param collection {@link Collection}
* @param length 期望长度
* @return {@code true} yes, {@code false} no
*/
public static boolean isLength(
final Collection collection,
final int length
) {
return collection != null && collection.size() == length;
}
// =
/**
* 判断 Collection 长度是否大于指定长度
* @param collection {@link Collection}
* @param length 指定长度
* @return {@code true} yes, {@code false} no
*/
public static boolean greaterThan(
final Collection collection,
final int length
) {
return collection != null && collection.size() > length;
}
/**
* 判断 Collection 长度是否大于等于指定长度
* @param collection {@link Collection}
* @param length 指定长度
* @return {@code true} yes, {@code false} no
*/
public static boolean greaterThanOrEqual(
final Collection collection,
final int length
) {
return collection != null && collection.size() >= length;
}
// =
/**
* 判断 Collection 长度是否小于指定长度
* @param collection {@link Collection}
* @param length 指定长度
* @return {@code true} yes, {@code false} no
*/
public static boolean lessThan(
final Collection collection,
final int length
) {
return collection != null && collection.size() < length;
}
/**
* 判断 Collection 长度是否小于等于指定长度
* @param collection {@link Collection}
* @param length 指定长度
* @return {@code true} yes, {@code false} no
*/
public static boolean lessThanOrEqual(
final Collection collection,
final int length
) {
return collection != null && collection.size() <= length;
}
// =============
// = 获取长度总和 =
// =============
/**
* 获取 Collection 数组长度总和
* @param collections Collection[]
* @return Collection 数组长度总和
*/
public static int getCount(final Collection... collections) {
if (collections == null) return 0;
int count = 0;
for (Collection collection : collections) {
count += length(collection);
}
return count;
}
// ==========
// = 数据获取 =
// ==========
/**
* 获取数据
* @param collection {@link Collection}
* @param pos 索引
* @param 泛型
* @return 对应索引的值
*/
public static T get(
final Collection collection,
final int pos
) {
if (collection != null) {
// 防止索引为负数
if (pos < 0) {
return null;
}
if (collection instanceof List) {
try {
return (T) ((List) collection).get(pos);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "get %s", pos);
}
} else {
try {
return (T) collection.toArray()[pos];
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "get %s", pos);
}
}
}
return null;
}
/**
* 获取第一条数据
* @param collection {@link Collection}
* @param 泛型
* @return 索引为 0 的值
*/
public static T getFirst(final Collection collection) {
return get(collection, 0);
}
/**
* 获取最后一条数据
* @param collection {@link Collection}
* @param 泛型
* @return 索引 length - 1 的值
*/
public static T getLast(final Collection collection) {
return get(collection, length(collection) - 1);
}
// =
/**
* 根据指定 value 获取 value 所在位置 + 偏移量的值
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param notNull 是否不允许值为 null
* @param offset 偏移量
* @param 泛型
* @return 对应索引的值
*/
public static T get(
final Collection collection,
final T value,
final int number,
final boolean notNull,
final int offset
) {
if (collection != null) {
if (notNull && value == null) {
return null;
}
try {
// 保存当前临时次数
int temp = number;
// 转换数组
T[] arrays = (T[]) collection.toArray();
// 进行循环判断
for (int i = 0, len = arrays.length; i < len; i++) {
T t = arrays[i];
// 判断值是否一样
if (equals(t, value)) {
if (temp - 1 < 0) {
return arrays[i + offset];
}
temp--;
}
}
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "get");
}
}
return null;
}
/**
* 根据指定 value 获取 value 所在位置 + 偏移量的索引
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param notNull 是否不允许值为 null
* @param offset 偏移量
* @param 泛型
* @return 对应的索引
*/
public static int getPosition(
final Collection collection,
final T value,
final int number,
final boolean notNull,
final int offset
) {
if (collection != null) {
if (notNull && value == null) {
return -1;
}
try {
// 保存当前临时次数
int temp = number;
// 转换数组
T[] arrays = (T[]) collection.toArray();
// 进行循环判断
for (int i = 0, len = arrays.length; i < len; i++) {
T t = arrays[i];
// 判断值是否一样
if (equals(t, value)) {
if (temp - 1 < 0) {
return i + offset;
}
temp--;
}
}
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getPosition");
}
}
return -1;
}
// =
/**
* 根据指定 value 获取索引
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return 对应的索引
*/
public static int getPosition(
final Collection collection,
final T value
) {
return getPosition(collection, value, 0, false, 0);
}
/**
* 根据指定 value 获取索引
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param 泛型
* @return 对应的索引
*/
public static int getPosition(
final Collection collection,
final T value,
final int number
) {
return getPosition(collection, value, number, false, 0);
}
/**
* 根据指定 value 获取索引
* @param collection {@link Collection}
* @param value 值
* @param notNull 是否不允许值为 null
* @param 泛型
* @return 对应的索引
*/
public static int getPosition(
final Collection collection,
final T value,
final boolean notNull
) {
return getPosition(collection, value, 0, notNull, 0);
}
/**
* 根据指定 value 获取索引
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param notNull 是否不允许值为 null
* @param 泛型
* @return 对应的索引
*/
public static int getPosition(
final Collection collection,
final T value,
final int number,
final boolean notNull
) {
return getPosition(collection, value, number, notNull, 0);
}
// =
/**
* 根据指定 value 获取索引, 不允许值为 null
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return 对应的索引
*/
public static int getPositionNotNull(
final Collection collection,
final T value
) {
return getPosition(collection, value, 0, true, 0);
}
/**
* 根据指定 value 获取索引, 不允许值为 null
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param 泛型
* @return 对应的索引
*/
public static int getPositionNotNull(
final Collection collection,
final T value,
final int number
) {
return getPosition(collection, value, number, true, 0);
}
// =
/**
* 根据指定 value 获取 value 所在位置的下一个值
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return 对应索引的值
*/
public static T getNext(
final Collection collection,
final T value
) {
return get(collection, value, 0, false, 1);
}
/**
* 根据指定 value 获取 value 所在位置的下一个值
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param 泛型
* @return 对应索引的值
*/
public static T getNext(
final Collection collection,
final T value,
final int number
) {
return get(collection, value, number, false, 1);
}
/**
* 根据指定 value 获取 value 所在位置的下一个值
* @param collection {@link Collection}
* @param value 值
* @param notNull 是否不允许值为 null
* @param 泛型
* @return 对应索引的值
*/
public static T getNext(
final Collection collection,
final T value,
final boolean notNull
) {
return get(collection, value, 0, notNull, 1);
}
/**
* 根据指定 value 获取 value 所在位置的下一个值
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param notNull 是否不允许值为 null
* @param 泛型
* @return 对应索引的值
*/
public static T getNext(
final Collection collection,
final T value,
final int number,
final boolean notNull
) {
return get(collection, value, number, notNull, 1);
}
// =
/**
* 根据指定 value 获取 value 所在位置的下一个值, 不允许值为 null
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return 对应索引的值
*/
public static T getNextNotNull(
final Collection collection,
final T value
) {
return get(collection, value, 0, true, 1);
}
/**
* 根据指定 value 获取 value 所在位置的下一个值, 不允许值为 null
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param 泛型
* @return 对应索引的值
*/
public static T getNextNotNull(
final Collection collection,
final T value,
final int number
) {
return get(collection, value, number, true, 1);
}
// =
/**
* 根据指定 value 获取 value 所在位置的上一个值
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return 对应索引的值
*/
public static T getPrevious(
final Collection collection,
final T value
) {
return get(collection, value, 0, false, -1);
}
/**
* 根据指定 value 获取 value 所在位置的上一个值
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param 泛型
* @return 对应索引的值
*/
public static T getPrevious(
final Collection collection,
final T value,
final int number
) {
return get(collection, value, number, false, -1);
}
/**
* 根据指定 value 获取 value 所在位置的上一个值
* @param collection {@link Collection}
* @param value 值
* @param notNull 是否不允许值为 null
* @param 泛型
* @return 对应索引的值
*/
public static T getPrevious(
final Collection collection,
final T value,
final boolean notNull
) {
return get(collection, value, 0, notNull, -1);
}
/**
* 根据指定 value 获取 value 所在位置的上一个值
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param notNull 是否不允许值为 null
* @param 泛型
* @return 对应索引的值
*/
public static T getPrevious(
final Collection collection,
final T value,
final int number,
final boolean notNull
) {
return get(collection, value, number, notNull, -1);
}
// =
/**
* 根据指定 value 获取 value 所在位置的上一个值, 不允许值为 null
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return 对应索引的值
*/
public static T getPreviousNotNull(
final Collection collection,
final T value
) {
return get(collection, value, 0, true, -1);
}
/**
* 根据指定 value 获取 value 所在位置的上一个值, 不允许值为 null
* @param collection {@link Collection}
* @param value 值
* @param number 符合条件次数 ( 从 0 开始, 0 = 1 )
* @param 泛型
* @return 对应索引的值
*/
public static T getPreviousNotNull(
final Collection collection,
final T value,
final int number
) {
return get(collection, value, number, true, -1);
}
// ==========
// = 添加数据 =
// ==========
/**
* 添加一条数据
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean add(
final Collection collection,
final T value
) {
return add(collection, value, false);
}
/**
* 添加一条数据 ( value 不允许为 null )
* @param collection {@link Collection}
* @param value 值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addNotNull(
final Collection collection,
final T value
) {
return add(collection, value, true);
}
/**
* 添加一条数据
* @param collection {@link Collection}
* @param value 值
* @param notNull 是否不允许添加 null 数据
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean add(
final Collection collection,
final T value,
final boolean notNull
) {
if (collection != null) {
if (notNull) {
if (value != null) {
try {
return collection.add(value);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "add notNull");
}
}
} else {
try {
return collection.add(value);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "add");
}
}
}
return false;
}
// =
/**
* 添加集合数据
* @param collection {@link Collection}
* @param values 准备添加的值 ( 集合 )
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addAll(
final Collection collection,
final Collection values
) {
return addAll(collection, values, false);
}
/**
* 添加集合数据 ( values 内的值不允许为 null )
* @param collection {@link Collection}
* @param values 准备添加的值 ( 集合 )
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addAllNotNull(
final Collection collection,
final Collection values
) {
return addAll(collection, values, true);
}
/**
* 添加集合数据
* @param collection {@link Collection}
* @param values 准备添加的值 ( 集合 )
* @param notNull 是否不允许添加 null 值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addAll(
final Collection collection,
final Collection values,
final boolean notNull
) {
if (collection != null && values != null) {
if (notNull) {
try {
for (T value : values) {
if (value != null) {
collection.add(value);
}
}
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "addAll notNull");
}
} else {
try {
return collection.addAll(values);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "addAll");
}
}
}
return false;
}
// =
/**
* 移除全部数据并添加集合数据
* @param collection {@link Collection}
* @param values 准备添加的值 ( 集合 )
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean clearAndAddAll(
final Collection collection,
final Collection values
) {
return clearAndAddAll(collection, values, false);
}
/**
* 移除全部数据并添加集合数据 ( values 内的值不允许为 null )
* @param collection {@link Collection}
* @param values 准备添加的值 ( 集合 )
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean clearAndAddAllNotNull(
final Collection collection,
final Collection values
) {
return clearAndAddAll(collection, values, true);
}
/**
* 移除全部数据并添加集合数据
* @param collection {@link Collection}
* @param values 准备添加的值 ( 集合 )
* @param notNull 是否不允许添加 null 值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean clearAndAddAll(
final Collection collection,
final Collection values,
final boolean notNull
) {
clearAll(collection);
return addAll(collection, values, notNull);
}
// =========================
// = 添加数据到指定索引 (List) =
// =========================
/**
* 添加一条数据到指定索引后
* @param index 索引
* @param list 集合
* @param value 值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean add(
final int index,
final List list,
final T value
) {
return add(index, list, value, false);
}
/**
* 添加一条数据到指定索引后 ( value 不允许为 null )
* @param index 索引
* @param list 集合
* @param value 值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addNotNull(
final int index,
final List list,
final T value
) {
return add(index, list, value, true);
}
/**
* 添加一条数据到指定索引后
* @param index 索引
* @param list 集合
* @param value 值
* @param notNull 是否不允许添加 null 数据
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean add(
final int index,
final List list,
final T value,
final boolean notNull
) {
if (list != null) {
if (notNull) {
if (value != null) {
try {
list.add(index, value);
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "add notNull");
}
}
} else {
try {
list.add(index, value);
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "add");
}
}
}
return false;
}
// =
/**
* 添加集合数据到指定索引后
* @param index 索引
* @param list 集合
* @param values 准备添加的值 ( 集合 )
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addAll(
final int index,
final List list,
final List values
) {
return addAll(index, list, values, false);
}
/**
* 添加集合数据到指定索引后 ( values 内的值不允许为 null )
* @param index 索引
* @param list 集合
* @param values 准备添加的值 ( 集合 )
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addAllNotNull(
final int index,
final List list,
final List values
) {
return addAll(index, list, values, true);
}
/**
* 添加集合数据到指定索引后
* @param index 索引
* @param list 集合
* @param values 准备添加的值 ( 集合 )
* @param notNull 是否不允许添加 null 值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean addAll(
final int index,
final List list,
final List values,
final boolean notNull
) {
if (list != null && values != null) {
if (notNull) {
try {
List tempList = new ArrayList<>();
for (T value : values) {
if (value != null) {
tempList.add(value);
}
}
// 添加到集合中
list.addAll(index, tempList);
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "addAll notNull");
}
} else {
try {
list.addAll(index, values);
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "addAll");
}
}
}
return false;
}
// ==========
// = 删除数据 =
// ==========
/**
* 移除一条数据
* @param collection {@link Collection}
* @param value 准备删除的值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean remove(
final Collection collection,
final T value
) {
if (collection != null) {
try {
return collection.remove(value);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "remove");
}
}
return false;
}
/**
* 移除一条数据
* @param list 集合
* @param pos 准备删除的索引
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static T remove(
final List list,
final int pos
) {
if (list != null) {
// 防止索引为负数
if (pos < 0) {
return null;
}
try {
return list.remove(pos);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "remove");
}
}
return null;
}
/**
* 移除集合数据
* @param collection {@link Collection}
* @param values 准备删除的集合
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean removeAll(
final Collection collection,
final Collection values
) {
if (collection != null && values != null) {
try {
return collection.removeAll(values);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "removeAll");
}
}
return false;
}
// =
/**
* 清空集合中符合指定 value 的全部数据
* @param collection {@link Collection}
* @param value 准备对比移除的值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean clear(
final Collection collection,
final T value
) {
if (collection != null) {
try {
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
T t = iterator.next();
// 判断值是否一样
if (equals(t, value)) {
iterator.remove();
}
}
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "clear");
}
}
return false;
}
/**
* 保留集合中符合指定 value 的全部数据
* @param collection {@link Collection}
* @param value 准备对比保留的值
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean clearNotBelong(
final Collection collection,
final T value
) {
if (collection != null) {
try {
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
T t = iterator.next();
// 判断值是否不一样 ( 移除不一样的 )
if (!equals(t, value)) {
iterator.remove();
}
}
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "clearNotBelong");
}
}
return false;
}
/**
* 清空集合全部数据
* @param collection {@link Collection}
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean clearAll(final Collection collection) {
if (collection != null) {
try {
collection.clear();
return true;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "clearAll");
}
}
return false;
}
/**
* 清空集合中为 null 的值
* @param collection {@link Collection}
* @param 泛型
* @return {@code true} success, {@code false} fail
*/
public static boolean clearNull(final Collection collection) {
return clear(collection, null);
}
// =================
// = 判断集合是否相同 =
// =================
/**
* 判断两个集合是否相同
* @param collection1 第一个集合
* @param collection2 第二个集合
* @param 泛型
* @return {@code true} yes, {@code false} no
*/
public static boolean isEqualCollection(
final Collection collection1,
final Collection collection2
) {
// 数据长度
int len;
// 判断数据是否相同
if (collection1 != null && collection2 != null && (len = collection1.size()) == collection2.size()) {
if (len == 0) return true;
// 进行判断类型, 如果不同, 则直接跳过不处理
if (!collection1.getClass().getName().equals(collection2.getClass().getName())) {
return false;
}
// 如果集合相等, 直接跳过
if (collection1.equals(collection2)) {
return true;
}
T[] arrays1, arrays2;
try {
// 转换数组, 防止异常
arrays1 = (T[]) collection1.toArray();
arrays2 = (T[]) collection2.toArray();
} catch (Exception e) {
return false;
}
for (int i = 0; i < len; i++) {
// 判断两个值是否一样
boolean equals = equals(arrays1[i], arrays2[i]);
// 如果不一样, 直接 return
if (!equals) {
return false;
}
}
return true;
}
// 如果不符合条件, 防止两个集合都是为 null
return (collection1 == null && collection2 == null);
}
/**
* 判断多个集合是否相同
* @param collections 集合数组
* @param 泛型
* @return {@code true} yes, {@code false} no
*/
public static boolean isEqualCollections(final Collection... collections) {
if (collections != null && collections.length >= 2) {
// 获取长度
int len = collections.length;
// 设置临时值为第一个
Collection temp = collections[0];
// 进行判断
for (int i = 1; i < len; i++) {
// 判断是否一样
boolean equalCollection = isEqualCollection(temp, collections[i]);
// 如果不一样, 直接返回
if (!equalCollection) {
return false;
}
}
return true;
}
return false;
}
// ==========
// = 集合处理 =
// ==========
// =======
// = 并集 =
// =======
/**
* 两个集合并集处理
* @param collection1 第一个集合
* @param collection2 第二个集合
* @param 泛型
* @return 并集集合
*/
public static Collection union(
final Collection collection1,
final Collection collection2
) {
if (collection1 != null && collection2 != null) {
try {
// 初始化新的集合, 默认保存第一个集合的数据
Set sets = new LinkedHashSet<>(collection1);
sets.addAll(collection2);
// 返回集合
return sets;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "union");
}
return null;
} else if (collection1 != null) {
return collection1;
}
return collection2;
}
/**
* 多个集合并集处理
* @param collections 集合数组
* @param 泛型
* @return 并集集合
*/
public static Collection unions(final Collection... collections) {
if (collections != null) {
int len = collections.length;
if (len >= 2) {
try {
// 保存第一个集合
Set sets = new LinkedHashSet<>();
// 防止集合为 null
if (collections[0] != null) {
sets.addAll(collections[0]);
}
// 进行循环处理
for (int i = 1; i < len; i++) {
// 获取集合值
Collection value = collections[i];
if (value != null) {
sets.addAll(value);
}
}
return sets;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "unions");
}
return null;
}
return collections[0];
}
return null;
}
// =======
// = 交集 =
// =======
/**
* 两个集合交集处理
* @param collection1 第一个集合
* @param collection2 第二个集合
* @param 泛型
* @return 交集集合
*/
public static Collection intersection(
final Collection collection1,
final Collection collection2
) {
if (collection1 != null && collection2 != null) {
try {
// 专门用于返回中转的集合
Set sets = new LinkedHashSet<>();
// 初始化新的集合, 默认保存第一个集合的数据
Set setsTemp = new LinkedHashSet<>(collection1);
// 循环第二个集合
for (T value : collection2) {
// 判断是否存在, 存在则保存
if (setsTemp.contains(value)) {
sets.add(value);
}
}
// 返回集合
return sets;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "intersection");
}
return null;
} else if (collection1 != null) {
return collection1;
}
return collection2;
}
/**
* 两个集合交集的补集处理
* @param collection1 第一个集合
* @param collection2 第二个集合
* @param 泛型
* @return 交集集合
*/
public static Collection disjunction(
final Collection collection1,
final Collection collection2
) {
try {
// 先进行并集处理
Collection unionC = union(collection1, collection2);
// 在进行交集处理
Collection intersectionC = intersection(collection1, collection2);
// 再进行移除处理
if (unionC != null && intersectionC != null) {
try {
// 移除数据
unionC.removeAll(intersectionC);
return unionC;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "disjunction");
}
}
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "disjunction");
}
return null;
}
/**
* 两个集合差集 ( 扣除 ) 处理
* @param collection1 第一个集合
* @param collection2 第二个集合
* @param 泛型
* @return 差集 ( 扣除 ) 集合
*/
public static Collection subtract(
final Collection collection1,
final Collection collection2
) {
try {
// 先进行交集处理
Collection intersectionC = intersection(collection1, collection2);
if (intersectionC != null) {
// 保存到新的集合中
Set sets = new LinkedHashSet<>(collection1);
// 进行移除
sets.removeAll(intersectionC);
// 返回集合
return sets;
}
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "subtract");
}
return null;
}
// ==========
// = 快捷方法 =
// ==========
/**
* 判断两个值是否一样
* @param value1 第一个值
* @param value2 第二个值
* @param 泛型
* @return {@code true} yes, {@code false} no
*/
public static boolean equals(
final T value1,
final T value2
) {
return ObjectUtils.equals(value1, value2);
}
// ==========
// = 转换处理 =
// ==========
/**
* 转换数组 to Object
* @param collection {@link Collection}
* @param 泛型
* @return 转换后的数组
*/
public static Object[] toArray(final Collection collection) {
if (collection != null) {
try {
return collection.toArray();
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "toArray");
}
}
return null;
}
/**
* 转换数组 to T
* @param collection {@link Collection}
* @param 泛型
* @return 转换后的泛型数组
*/
public static T[] toArrayT(final Collection collection) {
if (collection != null) {
try {
return new ArrayWithTypeToken(collection).create();
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "toArrayT");
}
}
return null;
}
/**
* 集合翻转处理
* @param collection {@link Collection}
* @param 泛型
* @return 翻转后的集合
*/
public static Collection reverse(final Collection collection) {
try {
// 返回集合
List lists = new ArrayList<>();
// 转换数据
T[] arrays = (T[]) collection.toArray();
// 循环处理
for (int i = arrays.length - 1; i >= 0; i--) {
lists.add(arrays[i]);
}
// 保存新的数据
return lists;
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "reverse");
}
return null;
}
// ============
// = 最小值索引 =
// ============
/**
* 获取集合中最小值索引
* @param list 集合
* @return 最小值索引
*/
public static int getMinimumIndexI(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Integer temp = list.get(index);
for (int i = 1; i < len; i++) {
Integer value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value < temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
/**
* 获取集合中最小值索引
* @param list 集合
* @return 最小值索引
*/
public static int getMinimumIndexL(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Long temp = list.get(index);
for (int i = 1; i < len; i++) {
Long value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value < temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
/**
* 获取集合中最小值索引
* @param list 集合
* @return 最小值索引
*/
public static int getMinimumIndexF(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Float temp = list.get(index);
for (int i = 1; i < len; i++) {
Float value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value < temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
/**
* 获取集合中最小值索引
* @param list 集合
* @return 最小值索引
*/
public static int getMinimumIndexD(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Double temp = list.get(index);
for (int i = 1; i < len; i++) {
Double value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value < temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
// ============
// = 最大值索引 =
// ============
/**
* 获取集合中最大值索引
* @param list 集合
* @return 最大值索引
*/
public static int getMaximumIndexI(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Integer temp = list.get(index);
for (int i = 1; i < len; i++) {
Integer value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value > temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
/**
* 获取集合中最大值索引
* @param list 集合
* @return 最大值索引
*/
public static int getMaximumIndexL(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Long temp = list.get(index);
for (int i = 1; i < len; i++) {
Long value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value > temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
/**
* 获取集合中最大值索引
* @param list 集合
* @return 最大值索引
*/
public static int getMaximumIndexF(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Float temp = list.get(index);
for (int i = 1; i < len; i++) {
Float value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value > temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
/**
* 获取集合中最大值索引
* @param list 集合
* @return 最大值索引
*/
public static int getMaximumIndexD(final List list) {
if (list != null) {
int len = list.size();
if (len > 0) {
int index = 0;
Double temp = list.get(index);
for (int i = 1; i < len; i++) {
Double value = list.get(i);
if (value != null) {
if (temp == null) {
index = i;
temp = value;
}
if (value > temp) {
index = i;
temp = value;
}
}
}
if (temp == null) {
return -1;
}
return index;
}
}
return -1;
}
// ============
// = 获取最小值 =
// ============
/**
* 获取集合中最小值
* @param list 集合
* @return 最小值
*/
public static int getMinimumI(final List list) {
try {
return list.get(getMinimumIndexI(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMinimumI");
}
return 0;
}
/**
* 获取集合中最小值
* @param list 集合
* @return 最小值
*/
public static long getMinimumL(final List list) {
try {
return list.get(getMinimumIndexL(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMinimumL");
}
return 0L;
}
/**
* 获取集合中最小值
* @param list 集合
* @return 最小值
*/
public static float getMinimumF(final List list) {
try {
return list.get(getMinimumIndexF(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMinimumF");
}
return 0F;
}
/**
* 获取集合中最小值
* @param list 集合
* @return 最小值
*/
public static double getMinimumD(final List list) {
try {
return list.get(getMinimumIndexD(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMinimumD");
}
return 0D;
}
// ============
// = 获取最大值 =
// ============
/**
* 获取集合中最大值
* @param list 集合
* @return 最大值
*/
public static int getMaximumI(final List list) {
try {
return list.get(getMaximumIndexI(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMaximumI");
}
return 0;
}
/**
* 获取集合中最大值
* @param list 集合
* @return 最大值
*/
public static long getMaximumL(final List list) {
try {
return list.get(getMaximumIndexL(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMaximumL");
}
return 0L;
}
/**
* 获取集合中最大值
* @param list 集合
* @return 最大值
*/
public static float getMaximumF(final List list) {
try {
return list.get(getMaximumIndexF(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMaximumF");
}
return 0F;
}
/**
* 获取集合中最大值
* @param list 集合
* @return 最大值
*/
public static double getMaximumD(final List list) {
try {
return list.get(getMaximumIndexD(list));
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "getMaximumD");
}
return 0D;
}
// =============
// = 计算集合总和 =
// =============
/**
* 计算集合总和
* @param lists 集合
* @return 集合总和
*/
public static int sumlistI(final List lists) {
return sumlistI(lists, 0, length(lists), 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @return 集合总和
*/
public static int sumlistI(
final List lists,
final int end
) {
return sumlistI(lists, 0, end, 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static int sumlistI(
final List lists,
final int end,
final int extra
) {
return sumlistI(lists, 0, end, extra);
}
/**
* 计算集合总和
* @param lists 集合
* @param start 开始位置
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static int sumlistI(
final List lists,
final int start,
final int end,
final int extra
) {
int total = 0;
if (lists != null) {
for (int i = start; i < end; i++) {
try {
total += (lists.get(i) + extra);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "sumlistI");
}
}
}
return total;
}
// =
/**
* 计算集合总和
* @param lists 集合
* @return 集合总和
*/
public static long sumlistL(final List lists) {
return sumlistL(lists, 0, length(lists), 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @return 集合总和
*/
public static long sumlistL(
final List lists,
final int end
) {
return sumlistL(lists, 0, end, 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static long sumlistL(
final List lists,
final int end,
final long extra
) {
return sumlistL(lists, 0, end, extra);
}
/**
* 计算集合总和
* @param lists 集合
* @param start 开始位置
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static long sumlistL(
final List lists,
final int start,
final int end,
final long extra
) {
long total = 0L;
if (lists != null) {
for (int i = start; i < end; i++) {
try {
total += (lists.get(i) + extra);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "sumlistL");
}
}
}
return total;
}
// =
/**
* 计算集合总和
* @param lists 集合
* @return 集合总和
*/
public static float sumlistF(final List lists) {
return sumlistF(lists, 0, length(lists), 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @return 集合总和
*/
public static float sumlistF(
final List lists,
final int end
) {
return sumlistF(lists, 0, end, 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static float sumlistF(
final List lists,
final int end,
final float extra
) {
return sumlistF(lists, 0, end, extra);
}
/**
* 计算集合总和
* @param lists 集合
* @param start 开始位置
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static float sumlistF(
final List lists,
final int start,
final int end,
final float extra
) {
float total = 0;
if (lists != null) {
for (int i = start; i < end; i++) {
try {
total += (lists.get(i) + extra);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "sumlistF");
}
}
}
return total;
}
// =
/**
* 计算集合总和
* @param lists 集合
* @return 集合总和
*/
public static double sumlistD(final List lists) {
return sumlistD(lists, 0, length(lists), 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @return 集合总和
*/
public static double sumlistD(
final List lists,
final int end
) {
return sumlistD(lists, 0, end, 0);
}
/**
* 计算集合总和
* @param lists 集合
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static double sumlistD(
final List lists,
final int end,
final double extra
) {
return sumlistD(lists, 0, end, extra);
}
/**
* 计算集合总和
* @param lists 集合
* @param start 开始位置
* @param end 结束位置
* @param extra 额外值
* @return 集合总和
*/
public static double sumlistD(
final List lists,
final int start,
final int end,
final double extra
) {
double total = 0;
if (lists != null) {
for (int i = start; i < end; i++) {
try {
total += (lists.get(i) + extra);
} catch (Exception e) {
JCLogUtils.eTag(TAG, e, "sumlistD");
}
}
}
return total;
}
// ============
// = 内部实现类 =
// ============
/**
* detail: 持有数组 TypeToken 实体类
* @author Ttt
*/
public static class ArrayWithTypeToken {
// 泛型数组
private T[] array;
public ArrayWithTypeToken(Collection collection) {
newInstance(collection);
}
public ArrayWithTypeToken(
Class type,
int size
) {
newInstance(type, size);
}
/**
* 添加数据
* @param index 索引
* @param item 数据
*/
public void put(
final int index,
final T item
) {
array[index] = item;
}
/**
* 获取对应索引的数据
* @param index 索引
* @return 对应索引的数据
*/
public T get(final int index) {
return array[index];
}
/**
* 获取数组
* @return 泛型数组
*/
public T[] create() {
return array;
}
// ==========
// = 内部方法 =
// ==========
/**
* 创建数组方法
* @param type 数组类型
* @param size 数组长度
*/
private void newInstance(
final Class type,
final int size
) {
array = (T[]) Array.newInstance(type, size);
}
/**
* 创建数组方法
* @param collection 集合
*/
private void newInstance(final Collection collection) {
// 泛型实体类
T value = null;
// 数组
Object[] objects = collection.toArray();
// 获取不为 null 的泛型实体类
for (Object object : objects) {
if (object != null) {
value = (T) object;
break;
}
}
newInstance((Class) value.getClass(), objects.length);
// 保存数据
for (int i = 0, len = objects.length; i < len; i++) {
Object object = objects[i];
put(i, (object != null) ? (T) object : null);
}
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy