All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.dahuatech.hutool.core.collection.CollUtil Maven / Gradle / Ivy

Go to download 

package com.dahuatech.hutool.core.collection;

import com.dahuatech.hutool.core.bean.BeanUtil;
import com.dahuatech.hutool.core.comparator.PinyinComparator;
import com.dahuatech.hutool.core.comparator.PropertyComparator;
import com.dahuatech.hutool.core.convert.Convert;
import com.dahuatech.hutool.core.convert.ConverterRegistry;
import com.dahuatech.hutool.core.exceptions.UtilException;
import com.dahuatech.hutool.core.lang.Editor;
import com.dahuatech.hutool.core.lang.Filter;
import com.dahuatech.hutool.core.lang.Matcher;
import com.dahuatech.hutool.core.map.MapUtil;
import com.dahuatech.hutool.core.util.*;

import java.lang.reflect.Type;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * 集合相关工具类
 *
 * 
此工具方法针对{@link Collection}及其实现类封装的工具。
 *
 * 
由于{@link Collection} 实现了{@link Iterable}接口，因此部分工具此类不提供，而是在{@link IterUtil} 中提供
 *
 * @author xiaoleilu
 * @see IterUtil
 * @since 3.1.1
 */
public class CollUtil {

  /**
   * 如果提供的集合为{@code null}，返回一个不可变的默认空集合，否则返回原集合

   * 空集合使用{@link Collections#emptySet()}
   *
   * @param  集合元素类型
   * @param set 提供的集合，可能为null
   * @return 原集合，若为null返回空集合
   * @since 4.6.3
   */
  public static  Set emptyIfNull(Set set) {
    return (null == set) ? Collections.emptySet() : set;
  }

  /**
   * 如果提供的集合为{@code null}，返回一个不可变的默认空集合，否则返回原集合

   * 空集合使用{@link Collections#emptyList()}
   *
   * @param  集合元素类型
   * @param set 提供的集合，可能为null
   * @return 原集合，若为null返回空集合
   * @since 4.6.3
   */
  public static  List emptyIfNull(List set) {
    return (null == set) ? Collections.emptyList() : set;
  }

  /**
   * 两个集合的并集

   * 针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留最多的个数

   * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]

   * 结果：[a, b, c, c, c]，此结果中只保留了三个c
   *
   * @param  集合元素类型
   * @param coll1 集合1
   * @param coll2 集合2
   * @return 并集的集合，返回 {@link ArrayList}
   */
  public static  Collection union(Collection coll1, Collection coll2) {
    final ArrayList list = new ArrayList<>();
    if (isEmpty(coll1)) {
      list.addAll(coll2);
    } else if (isEmpty(coll2)) {
      list.addAll(coll1);
    } else {
      final Map map1 = countMap(coll1);
      final Map map2 = countMap(coll2);
      final Set elts = newHashSet(coll2);
      elts.addAll(coll1);
      int m;
      for (T t : elts) {
        m = Math.max(Convert.toInt(map1.get(t), 0), Convert.toInt(map2.get(t), 0));
        for (int i = 0; i < m; i++) {
          list.add(t);
        }
      }
    }
    return list;
  }

  /**
   * 多个集合的并集

   * 针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留最多的个数

   * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]

   * 结果：[a, b, c, c, c]，此结果中只保留了三个c
   *
   * @param  集合元素类型
   * @param coll1 集合1
   * @param coll2 集合2
   * @param otherColls 其它集合
   * @return 并集的集合，返回 {@link ArrayList}
   */
  @SafeVarargs
  public static  Collection union(
      Collection coll1, Collection coll2, Collection... otherColls) {
    Collection union = union(coll1, coll2);
    for (Collection coll : otherColls) {
      union = union(union, coll);
    }
    return union;
  }

  /**
   * 两个集合的交集

   * 针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留最少的个数

   * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]

   * 结果：[a, b, c, c]，此结果中只保留了两个c
   *
   * @param  集合元素类型
   * @param coll1 集合1
   * @param coll2 集合2
   * @return 交集的集合，返回 {@link ArrayList}
   */
  public static  Collection intersection(Collection coll1, Collection coll2) {
    final ArrayList list = new ArrayList<>();
    if (isNotEmpty(coll1) && isNotEmpty(coll2)) {
      final Map map1 = countMap(coll1);
      final Map map2 = countMap(coll2);
      final Set elts = newHashSet(coll2);
      int m;
      for (T t : elts) {
        m = Math.min(Convert.toInt(map1.get(t), 0), Convert.toInt(map2.get(t), 0));
        for (int i = 0; i < m; i++) {
          list.add(t);
        }
      }
    }
    return list;
  }

  /**
   * 多个集合的交集

   * 针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留最少的个数

   * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]

   * 结果：[a, b, c, c]，此结果中只保留了两个c
   *
   * @param  集合元素类型
   * @param coll1 集合1
   * @param coll2 集合2
   * @param otherColls 其它集合
   * @return 并集的集合，返回 {@link ArrayList}
   */
  @SafeVarargs
  public static  Collection intersection(
      Collection coll1, Collection coll2, Collection... otherColls) {
    Collection intersection = intersection(coll1, coll2);
    if (isEmpty(intersection)) {
      return intersection;
    }
    for (Collection coll : otherColls) {
      intersection = intersection(intersection, coll);
      if (isEmpty(intersection)) {
        return intersection;
      }
    }
    return intersection;
  }

  /**
   * 两个集合的差集

   * 针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留两个集合中此元素个数差的个数

   * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]

   * 结果：[c]，此结果中只保留了一个

   * 任意一个集合为空，返回另一个集合

   * 两个集合无交集则返回两个集合的组合
   *
   * @param  集合元素类型
   * @param coll1 集合1
   * @param coll2 集合2
   * @return 差集的集合，返回 {@link ArrayList}
   */
  public static  Collection disjunction(Collection coll1, Collection coll2) {
    if (isEmpty(coll1)) {
      return coll2;
    }
    if (isEmpty(coll2)) {
      return coll1;
    }

    final ArrayList result = new ArrayList<>();
    final Map map1 = countMap(coll1);
    final Map map2 = countMap(coll2);
    final Set elts = newHashSet(coll2);
    elts.addAll(coll1);
    int m;
    for (T t : elts) {
      m = Math.abs(Convert.toInt(map1.get(t), 0) - Convert.toInt(map2.get(t), 0));
      for (int i = 0; i < m; i++) {
        result.add(t);
      }
    }
    return result;
  }

  /**
   * 判断指定集合是否包含指定值，如果集合为空（null或者空），返回{@code false}，否则找到元素返回{@code true}
   *
   * @param collection 集合
   * @param value 需要查找的值
   * @return 如果集合为空（null或者空），返回{@code false}，否则找到元素返回{@code true}
   * @since 4.1.10
   */
  public static boolean contains(Collection collection, Object value) {
    return isNotEmpty(collection) && collection.contains(value);
  }

  /**
   * 其中一个集合在另一个集合中是否至少包含一个元素，即是两个集合是否至少有一个共同的元素
   *
   * @param coll1 集合1
   * @param coll2 集合2
   * @return 其中一个集合在另一个集合中是否至少包含一个元素
   * @see #intersection
   * @since 2.1
   */
  public static boolean containsAny(Collection coll1, Collection coll2) {
    if (isEmpty(coll1) || isEmpty(coll2)) {
      return false;
    }
    if (coll1.size() < coll2.size()) {
      for (Object object : coll1) {
        if (coll2.contains(object)) {
          return true;
        }
      }
    } else {
      for (Object object : coll2) {
        if (coll1.contains(object)) {
          return true;
        }
      }
    }
    return false;
  }

  /**
   * 集合1中是否包含集合2中所有的元素，即集合2是否为集合1的子集
   *
   * @param coll1 集合1
   * @param coll2 集合2
   * @return 集合1中是否包含集合2中所有的元素
   * @since 4.5.12
   */
  public static boolean containsAll(Collection coll1, Collection coll2) {
    if (isEmpty(coll1) || isEmpty(coll2) || coll1.size() < coll2.size()) {
      return false;
    }

    for (Object object : coll2) {
      if (false == coll1.contains(object)) {
        return false;
      }
    }
    return true;
  }

  /**
   * 根据集合返回一个元素计数的 {@link Map}

   * 所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value

   * 例如：[a,b,c,c,c] 得到：

   * a: 1

   * b: 1

   * c: 3

   *
   * @param  集合元素类型
   * @param collection 集合
   * @return {@link Map}
   * @see IterUtil#countMap(Iterable)
   */
  public static  Map countMap(Iterable collection) {
    return IterUtil.countMap(collection);
  }

  /**
   * 以 conjunction 为分隔符将集合转换为字符串

   * 如果集合元素为数组、{@link Iterable}或{@link Iterator}，则递归组合其为字符串
   *
   * @param  集合元素类型
   * @param iterable {@link Iterable}
   * @param conjunction 分隔符
   * @return 连接后的字符串
   * @see IterUtil#join(Iterable, CharSequence)
   */
  public static  String join(Iterable iterable, CharSequence conjunction) {
    return IterUtil.join(iterable, conjunction);
  }

  /**
   * 以 conjunction 为分隔符将集合转换为字符串

   * 如果集合元素为数组、{@link Iterable}或{@link Iterator}，则递归组合其为字符串
   *
   * @param  集合元素类型
   * @param iterator 集合
   * @param conjunction 分隔符
   * @return 连接后的字符串
   * @see IterUtil#join(Iterator, CharSequence)
   */
  public static  String join(Iterator iterator, CharSequence conjunction) {
    return IterUtil.join(iterator, conjunction);
  }

  /**
   * 切取部分数据

   * 切取后的栈将减少这些元素
   *
   * @param  集合元素类型
   * @param surplusAlaDatas 原数据
   * @param partSize 每部分数据的长度
   * @return 切取出的数据或null
   */
  public static  List popPart(Stack surplusAlaDatas, int partSize) {
    if (isEmpty(surplusAlaDatas)) {
      return null;
    }

    final List currentAlaDatas = new ArrayList<>();
    int size = surplusAlaDatas.size();
    // 切割
    if (size > partSize) {
      for (int i = 0; i < partSize; i++) {
        currentAlaDatas.add(surplusAlaDatas.pop());
      }
    } else {
      for (int i = 0; i < size; i++) {
        currentAlaDatas.add(surplusAlaDatas.pop());
      }
    }
    return currentAlaDatas;
  }

  /**
   * 切取部分数据

   * 切取后的栈将减少这些元素
   *
   * @param  集合元素类型
   * @param surplusAlaDatas 原数据
   * @param partSize 每部分数据的长度
   * @return 切取出的数据或null
   */
  public static  List popPart(Deque surplusAlaDatas, int partSize) {
    if (isEmpty(surplusAlaDatas)) {
      return null;
    }

    final List currentAlaDatas = new ArrayList<>();
    int size = surplusAlaDatas.size();
    // 切割
    if (size > partSize) {
      for (int i = 0; i < partSize; i++) {
        currentAlaDatas.add(surplusAlaDatas.pop());
      }
    } else {
      for (int i = 0; i < size; i++) {
        currentAlaDatas.add(surplusAlaDatas.pop());
      }
    }
    return currentAlaDatas;
  }

  // -----------------------------------------------------------------------------------------------
  // new HashMap

  /**
   * 新建一个HashMap
   *
   * @param  Key类型
   * @param  Value类型
   * @return HashMap对象
   * @see MapUtil#newHashMap()
   */
  public static  HashMap newHashMap() {
    return MapUtil.newHashMap();
  }

  /**
   * 新建一个HashMap
   *
   * @param  Key类型
   * @param  Value类型
   * @param size 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75
   * @param isOrder Map的Key是否有序，有序返回 {@link LinkedHashMap}，否则返回 {@link HashMap}
   * @return HashMap对象
   * @see MapUtil#newHashMap(int, boolean)
   * @since 3.0.4
   */
  public static  HashMap newHashMap(int size, boolean isOrder) {
    return MapUtil.newHashMap(size, isOrder);
  }

  /**
   * 新建一个HashMap
   *
   * @param  Key类型
   * @param  Value类型
   * @param size 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75
   * @return HashMap对象
   * @see MapUtil#newHashMap(int)
   */
  public static  HashMap newHashMap(int size) {
    return MapUtil.newHashMap(size);
  }

  // -----------------------------------------------------------------------------------------------
  // new HashSet

  /**
   * 新建一个HashSet
   *
   * @param  集合元素类型
   * @param ts 元素数组
   * @return HashSet对象
   */
  @SafeVarargs
  public static  HashSet newHashSet(T... ts) {
    return newHashSet(false, ts);
  }

  /**
   * 新建一个LinkedHashSet
   *
   * @param  集合元素类型
   * @param ts 元素数组
   * @return HashSet对象
   * @since 4.1.10
   */
  @SafeVarargs
  public static  LinkedHashSet newLinkedHashSet(T... ts) {
    return (LinkedHashSet) newHashSet(true, ts);
  }

  /**
   * 新建一个HashSet
   *
   * @param  集合元素类型
   * @param isSorted 是否有序，有序返回 {@link LinkedHashSet}，否则返回 {@link HashSet}
   * @param ts 元素数组
   * @return HashSet对象
   */
  @SafeVarargs
  public static  HashSet newHashSet(boolean isSorted, T... ts) {
    if (null == ts) {
      return isSorted ? new LinkedHashSet() : new HashSet();
    }
    int initialCapacity = Math.max((int) (ts.length / .75f) + 1, 16);
    final HashSet set =
        isSorted ? new LinkedHashSet(initialCapacity) : new HashSet(initialCapacity);
    Collections.addAll(set, ts);
    return set;
  }

  /**
   * 新建一个HashSet
   *
   * @param  集合元素类型
   * @param collection 集合
   * @return HashSet对象
   */
  public static  HashSet newHashSet(Collection collection) {
    return newHashSet(false, collection);
  }

  /**
   * 新建一个HashSet
   *
   * @param  集合元素类型
   * @param isSorted 是否有序，有序返回 {@link LinkedHashSet}，否则返回{@link HashSet}
   * @param collection 集合，用于初始化Set
   * @return HashSet对象
   */
  public static  HashSet newHashSet(boolean isSorted, Collection collection) {
    return isSorted ? new LinkedHashSet<>(collection) : new HashSet<>(collection);
  }

  /**
   * 新建一个HashSet
   *
   * @param  集合元素类型
   * @param isSorted 是否有序，有序返回 {@link LinkedHashSet}，否则返回{@link HashSet}
   * @param iter {@link Iterator}
   * @return HashSet对象
   * @since 3.0.8
   */
  public static  HashSet newHashSet(boolean isSorted, Iterator iter) {
    if (null == iter) {
      return newHashSet(isSorted, (T[]) null);
    }
    final HashSet set = isSorted ? new LinkedHashSet() : new HashSet();
    while (iter.hasNext()) {
      set.add(iter.next());
    }
    return set;
  }

  /**
   * 新建一个HashSet
   *
   * @param  集合元素类型
   * @param isSorted 是否有序，有序返回 {@link LinkedHashSet}，否则返回{@link HashSet}
   * @param enumeration {@link Enumeration}
   * @return HashSet对象
   * @since 3.0.8
   */
  public static  HashSet newHashSet(boolean isSorted, Enumeration enumeration) {
    if (null == enumeration) {
      return newHashSet(isSorted, (T[]) null);
    }
    final HashSet set = isSorted ? new LinkedHashSet() : new HashSet();
    while (enumeration.hasMoreElements()) {
      set.add(enumeration.nextElement());
    }
    return set;
  }

  // -----------------------------------------------------------------------------------------------
  // List

  /**
   * 新建一个空List
   *
   * @param  集合元素类型
   * @param isLinked 是否新建LinkedList
   * @return List对象
   * @since 4.1.2
   */
  public static  List list(boolean isLinked) {
    return isLinked ? new LinkedList() : new ArrayList();
  }

  /**
   * 新建一个List
   *
   * @param  集合元素类型
   * @param isLinked 是否新建LinkedList
   * @param values 数组
   * @return List对象
   * @since 4.1.2
   */
  @SafeVarargs
  public static  List list(boolean isLinked, T... values) {
    if (ArrayUtil.isEmpty(values)) {
      return list(isLinked);
    }
    final List arrayList = isLinked ? new LinkedList() : new ArrayList(values.length);
    Collections.addAll(arrayList, values);
    return arrayList;
  }

  /**
   * 新建一个List
   *
   * @param  集合元素类型
   * @param isLinked 是否新建LinkedList
   * @param collection 集合
   * @return List对象
   * @since 4.1.2
   */
  public static  List list(boolean isLinked, Collection collection) {
    if (null == collection) {
      return list(isLinked);
    }
    return isLinked ? new LinkedList<>(collection) : new ArrayList<>(collection);
  }

  /**
   * 新建一个List

   * 提供的参数为null时返回空{@link ArrayList}
   *
   * @param  集合元素类型
   * @param isLinked 是否新建LinkedList
   * @param iterable {@link Iterable}
   * @return List对象
   * @since 4.1.2
   */
  public static  List list(boolean isLinked, Iterable iterable) {
    if (null == iterable) {
      return list(isLinked);
    }
    return list(isLinked, iterable.iterator());
  }

  /**
   * 新建一个ArrayList

   * 提供的参数为null时返回空{@link ArrayList}
   *
   * @param  集合元素类型
   * @param isLinked 是否新建LinkedList
   * @param iter {@link Iterator}
   * @return ArrayList对象
   * @since 4.1.2
   */
  public static  List list(boolean isLinked, Iterator iter) {
    final List list = list(isLinked);
    if (null != iter) {
      while (iter.hasNext()) {
        list.add(iter.next());
      }
    }
    return list;
  }

  /**
   * 新建一个List

   * 提供的参数为null时返回空{@link ArrayList}
   *
   * @param  集合元素类型
   * @param isLinked 是否新建LinkedList
   * @param enumration {@link Enumeration}
   * @return ArrayList对象
   * @since 3.0.8
   */
  public static  List list(boolean isLinked, Enumeration enumration) {
    final List list = list(isLinked);
    if (null != enumration) {
      while (enumration.hasMoreElements()) {
        list.add(enumration.nextElement());
      }
    }
    return list;
  }

  /**
   * 新建一个ArrayList
   *
   * @param  集合元素类型
   * @param values 数组
   * @return ArrayList对象
   */
  @SafeVarargs
  public static  ArrayList newArrayList(T... values) {
    return (ArrayList) list(false, values);
  }

  /**
   * 数组转为ArrayList
   *
   * @param  集合元素类型
   * @param values 数组
   * @return ArrayList对象
   * @since 4.0.11
   */
  @SafeVarargs
  public static  ArrayList toList(T... values) {
    return newArrayList(values);
  }

  /**
   * 新建一个ArrayList
   *
   * @param  集合元素类型
   * @param collection 集合
   * @return ArrayList对象
   */
  public static  ArrayList newArrayList(Collection collection) {
    return (ArrayList) list(false, collection);
  }

  /**
   * 新建一个ArrayList

   * 提供的参数为null时返回空{@link ArrayList}
   *
   * @param  集合元素类型
   * @param iterable {@link Iterable}
   * @return ArrayList对象
   * @since 3.1.0
   */
  public static  ArrayList newArrayList(Iterable iterable) {
    return (ArrayList) list(false, iterable);
  }

  /**
   * 新建一个ArrayList

   * 提供的参数为null时返回空{@link ArrayList}
   *
   * @param  集合元素类型
   * @param iter {@link Iterator}
   * @return ArrayList对象
   * @since 3.0.8
   */
  public static  ArrayList newArrayList(Iterator iter) {
    return (ArrayList) list(false, iter);
  }

  /**
   * 新建一个ArrayList

   * 提供的参数为null时返回空{@link ArrayList}
   *
   * @param  集合元素类型
   * @param enumration {@link Enumeration}
   * @return ArrayList对象
   * @since 3.0.8
   */
  public static  ArrayList newArrayList(Enumeration enumration) {
    return (ArrayList) list(false, enumration);
  }

  // ----------------------------------------------------------------------new LinkedList

  /**
   * 新建LinkedList
   *
   * @param values 数组
   * @param  类型
   * @return LinkedList
   * @since 4.1.2
   */
  @SafeVarargs
  public static  LinkedList newLinkedList(T... values) {
    return (LinkedList) list(true, values);
  }

  /**
   * 新建一个CopyOnWriteArrayList
   *
   * @param  集合元素类型
   * @param collection 集合
   * @return {@link CopyOnWriteArrayList}
   */
  public static  CopyOnWriteArrayList newCopyOnWriteArrayList(Collection collection) {
    return (null == collection)
        ? (new CopyOnWriteArrayList())
        : (new CopyOnWriteArrayList(collection));
  }

  /**
   * 新建{@link BlockingQueue}

   * 在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。
   *
   * @param  集合类型
   * @param capacity 容量
   * @param isLinked 是否为链表形式
   * @return {@link BlockingQueue}
   * @since 3.3.0
   */
  public static  BlockingQueue newBlockingQueue(int capacity, boolean isLinked) {
    BlockingQueue queue;
    if (isLinked) {
      queue = new LinkedBlockingDeque<>(capacity);
    } else {
      queue = new ArrayBlockingQueue<>(capacity);
    }
    return queue;
  }

  /**
   * 创建新的集合对象
   *
   * @param  集合类型
   * @param collectionType 集合类型
   * @return 集合类型对应的实例
   * @since 3.0.8
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  public static  Collection create(Class collectionType) {
    Collection list;
    if (collectionType.isAssignableFrom(AbstractCollection.class)) {
      // 抽象集合默认使用ArrayList
      list = new ArrayList<>();
    }

    // Set
    else if (collectionType.isAssignableFrom(HashSet.class)) {
      list = new HashSet<>();
    } else if (collectionType.isAssignableFrom(LinkedHashSet.class)) {
      list = new LinkedHashSet<>();
    } else if (collectionType.isAssignableFrom(TreeSet.class)) {
      list = new TreeSet<>();
    } else if (collectionType.isAssignableFrom(EnumSet.class)) {
      list =
          (Collection) EnumSet.noneOf((Class) ClassUtil.getTypeArgument(collectionType));
    }

    // List
    else if (collectionType.isAssignableFrom(ArrayList.class)) {
      list = new ArrayList<>();
    } else if (collectionType.isAssignableFrom(LinkedList.class)) {
      list = new LinkedList<>();
    }

    // Others，直接实例化
    else {
      try {
        list = (Collection) ReflectUtil.newInstance(collectionType);
      } catch (Exception e) {
        throw new UtilException(e);
      }
    }
    return list;
  }

  /**
   * 创建Map

   * 传入抽象Map{@link AbstractMap}和{@link Map}类将默认创建{@link HashMap}
   *
   * @param  map键类型
   * @param  map值类型
   * @param mapType map类型
   * @return {@link Map}实例
   * @see MapUtil#createMap(Class)
   */
  public static  Map createMap(Class mapType) {
    return MapUtil.createMap(mapType);
  }

  /**
   * 去重集合
   *
   * @param  集合元素类型
   * @param collection 集合
   * @return {@link ArrayList}
   */
  public static  ArrayList distinct(Collection collection) {
    if (isEmpty(collection)) {
      return new ArrayList<>();
    } else if (collection instanceof Set) {
      return new ArrayList<>(collection);
    } else {
      return new ArrayList<>(new LinkedHashSet<>(collection));
    }
  }

  /**
   * 截取集合的部分
   *
   * @param  集合元素类型
   * @param list 被截取的数组
   * @param start 开始位置（包含）
   * @param end 结束位置（不包含）
   * @return 截取后的数组，当开始位置超过最大时，返回空的List
   */
  public static  List sub(List list, int start, int end) {
    return sub(list, start, end, 1);
  }

  /**
   * 截取集合的部分
   *
   * @param  集合元素类型
   * @param list 被截取的数组
   * @param start 开始位置（包含）
   * @param end 结束位置（不包含）
   * @param step 步进
   * @return 截取后的数组，当开始位置超过最大时，返回空的List
   * @since 4.0.6
   */
  public static  List sub(List list, int start, int end, int step) {
    if (list == null) {
      return null;
    }

    if (list.isEmpty()) {
      return new ArrayList<>(0);
    }

    final int size = list.size();
    if (start < 0) {
      start += size;
    }
    if (end < 0) {
      end += size;
    }
    if (start == size) {
      return new ArrayList<>(0);
    }
    if (start > end) {
      int tmp = start;
      start = end;
      end = tmp;
    }
    if (end > size) {
      if (start >= size) {
        return new ArrayList<>(0);
      }
      end = size;
    }

    if (step <= 1) {
      return list.subList(start, end);
    }

    final List result = new ArrayList<>();
    for (int i = start; i < end; i += step) {
      result.add(list.get(i));
    }
    return result;
  }

  /**
   * 截取集合的部分
   *
   * @param  集合元素类型
   * @param collection 被截取的数组
   * @param start 开始位置（包含）
   * @param end 结束位置（不包含）
   * @return 截取后的数组，当开始位置超过最大时，返回null
   */
  public static  List sub(Collection collection, int start, int end) {
    return sub(collection, start, end, 1);
  }

  /**
   * 截取集合的部分
   *
   * @param  集合元素类型
   * @param list 被截取的数组
   * @param start 开始位置（包含）
   * @param end 结束位置（不包含）
   * @param step 步进
   * @return 截取后的数组，当开始位置超过最大时，返回空集合
   * @since 4.0.6
   */
  public static  List sub(Collection list, int start, int end, int step) {
    if (list == null || list.isEmpty()) {
      return null;
    }

    return sub(new ArrayList<>(list), start, end, step);
  }

  /**
   * 对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表
   *
   * @param  集合元素类型
   * @param collection 集合
   * @param size 每个段的长度
   * @return 分段列表
   */
  public static  List> split(Collection collection, int size) {
    final List> result = new ArrayList<>();

    ArrayList subList = new ArrayList<>(size);
    for (T t : collection) {
      if (subList.size() >= size) {
        result.add(subList);
        subList = new ArrayList<>(size);
      }
      subList.add(t);
    }
    result.add(subList);
    return result;
  }

  /**
   * 过滤，此方法产生一个新集合

   * 过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
   *
   * 
   * 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
   * 2、修改元素对象，返回集合中为修改后的对象
   * 

   *
   * @param  集合元素类型
   * @param collection 集合
   * @param editor 编辑器接口
   * @return 过滤后的集合
   */
  public static  Collection filter(Collection collection, Editor editor) {
    if (null == collection || null == editor) {
      return collection;
    }

    Collection collection2 = ObjectUtil.clone(collection);
    try {
      collection2.clear();
    } catch (UnsupportedOperationException e) {
      // 克隆后的对象不支持清空，说明为不可变集合对象，使用默认的ArrayList保存结果
      collection2 = new ArrayList<>();
    }

    T modified;
    for (T t : collection) {
      modified = editor.edit(t);
      if (null != modified) {
        collection2.add(modified);
      }
    }
    return collection2;
  }

  /**
   * 过滤

   * 过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
   *
   * 
   * 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
   * 2、修改元素对象，返回集合中为修改后的对象
   * 

   *
   * @param  集合元素类型
   * @param list 集合
   * @param editor 编辑器接口
   * @return 过滤后的数组
   * @since 4.1.8
   */
  public static  List filter(List list, Editor editor) {
    if (null == list || null == editor) {
      return list;
    }

    final List list2 =
        (list instanceof LinkedList) ? new LinkedList() : new ArrayList(list.size());
    T modified;
    for (T t : list) {
      modified = editor.edit(t);
      if (null != modified) {
        list2.add(modified);
      }
    }
    return list2;
  }

  /**
   * 过滤

   * 过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
   *
   * 
   * 1、过滤出需要的对象，{@link Filter#accept(Object)}方法返回true的对象将被加入结果集合中
   * 

   *
   * @param  集合元素类型
   * @param collection 集合
   * @param filter 过滤器
   * @return 过滤后的数组
   * @since 3.1.0
   */
  public static  Collection filterNew(Collection collection, Filter filter) {
    if (null == collection || null == filter) {
      return collection;
    }

    Collection collection2 = ObjectUtil.clone(collection);
    try {
      collection2.clear();
    } catch (UnsupportedOperationException e) {
      // 克隆后的对象不支持清空，说明为不可变集合对象，使用默认的ArrayList保存结果
      collection2 = new ArrayList<>();
    }

    for (T t : collection) {
      if (filter.accept(t)) {
        collection2.add(t);
      }
    }
    return collection2;
  }

  /**
   * 过滤

   * 过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
   *
   * 
   * 1、过滤出需要的对象，{@link Filter#accept(Object)}方法返回true的对象将被加入结果集合中
   * 

   *
   * @param  集合元素类型
   * @param list 集合
   * @param filter 过滤器
   * @return 过滤后的数组
   * @since 4.1.8
   */
  public static  List filterNew(List list, Filter filter) {
    if (null == list || null == filter) {
      return list;
    }
    final List list2 =
        (list instanceof LinkedList) ? new LinkedList() : new ArrayList(list.size());
    for (T t : list) {
      if (filter.accept(t)) {
        list2.add(t);
      }
    }
    return list2;
  }

  /**
   * 去掉集合中的多个元素，此方法直接修改原集合
   *
   * @param  集合类型
   * @param  集合元素类型
   * @param collection 集合
   * @param elesRemoved 被去掉的元素数组
   * @return 原集合
   * @since 4.1.0
   */
  @SuppressWarnings("unchecked")
  public static , E> T removeAny(T collection, E... elesRemoved) {
    collection.removeAll(newHashSet(elesRemoved));
    return collection;
  }

  /**
   * 去除指定元素，此方法直接修改原集合
   *
   * @param  集合类型
   * @param  集合元素类型
   * @param collection 集合
   * @param filter 过滤器
   * @return 处理后的集合
   * @since 4.6.5
   */
  public static , E> T filter(T collection, final Filter filter) {
    return IterUtil.filter(collection, filter);
  }

  /**
   * 去除{@code null} 元素，此方法直接修改原集合
   *
   * @param  集合类型
   * @param  集合元素类型
   * @param collection 集合
   * @return 处理后的集合
   * @since 3.2.2
   */
  public static , E> T removeNull(T collection) {
    return filter(
        collection,
        new Filter() {
          @Override
          public boolean accept(E e) {
            return null != e;
          }
        });
  }

  /**
   * 去除{@code null}或者"" 元素，此方法直接修改原集合
   *
   * @param  集合类型
   * @param  集合元素类型
   * @param collection 集合
   * @return 处理后的集合
   * @since 3.2.2
   */
  public static , E extends CharSequence> T removeEmpty(T collection) {
    return filter(
        collection,
        new Filter() {
          @Override
          public boolean accept(E e) {
            return StrUtil.isNotEmpty(e);
          }
        });
  }

  /**
   * 去除{@code null}或者""或者空白字符串 元素，此方法直接修改原集合
   *
   * @param  集合类型
   * @param  集合元素类型
   * @param collection 集合
   * @return 处理后的集合
   * @since 3.2.2
   */
  public static , E extends CharSequence> T removeBlank(T collection) {
    return filter(
        collection,
        new Filter() {
          @Override
          public boolean accept(E e) {
            return StrUtil.isNotBlank(e);
          }
        });
  }

  /**
   * 通过Editor抽取集合元素中的某些值返回为新列表

   * 例如提供的是一个Bean列表，通过Editor接口实现获取某个字段值，返回这个字段值组成的新列表
   *
   * @param collection 原集合
   * @param editor 编辑器
   * @return 抽取后的新列表
   */
  public static List extract(Iterable collection, Editor editor) {
    return extract(collection, editor, false);
  }

  /**
   * 通过Editor抽取集合元素中的某些值返回为新列表

   * 例如提供的是一个Bean列表，通过Editor接口实现获取某个字段值，返回这个字段值组成的新列表
   *
   * @param collection 原集合
   * @param editor 编辑器
   * @param ignoreNull 是否忽略空值
   * @return 抽取后的新列表
   * @since 4.5.7
   */
  public static List extract(
      Iterable collection, Editor editor, boolean ignoreNull) {
    final List fieldValueList = new ArrayList<>();
    if (null == collection) {
      return fieldValueList;
    }

    Object value;
    for (Object bean : collection) {
      value = editor.edit(bean);
      if (null == value && ignoreNull) {
        continue;
      }
      fieldValueList.add(value);
    }
    return fieldValueList;
  }

  /**
   * 获取给定Bean列表中指定字段名对应字段值的列表

   * 列表元素支持Bean与Map
   *
   * @param collection Bean集合或Map集合
   * @param fieldName 字段名或map的键
   * @return 字段值列表
   * @since 3.1.0
   */
  public static List getFieldValues(Iterable collection, final String fieldName) {
    return getFieldValues(collection, fieldName, false);
  }

  /**
   * 获取给定Bean列表中指定字段名对应字段值的列表

   * 列表元素支持Bean与Map
   *
   * @param collection Bean集合或Map集合
   * @param fieldName 字段名或map的键
   * @param ignoreNull 是否忽略值为{@code null}的字段
   * @return 字段值列表
   * @since 4.5.7
   */
  public static List getFieldValues(
      Iterable collection, final String fieldName, boolean ignoreNull) {
    return extract(
        collection,
        new Editor() {
          @Override
          public Object edit(Object bean) {
            if (bean instanceof Map) {
              return ((Map) bean).get(fieldName);
            } else {
              return ReflectUtil.getFieldValue(bean, fieldName);
            }
          }
        },
        ignoreNull);
  }

  /**
   * 获取给定Bean列表中指定字段名对应字段值的列表

   * 列表元素支持Bean与Map
   *
   * @param  元素类型
   * @param collection Bean集合或Map集合
   * @param fieldName 字段名或map的键
   * @param elementType 元素类型类
   * @return 字段值列表
   * @since 4.5.6
   */
  public static  List getFieldValues(
      Iterable collection, final String fieldName, final Class elementType) {
    List fieldValues = getFieldValues(collection, fieldName);
    return Convert.toList(elementType, fieldValues);
  }

  /**
   * 查找第一个匹配元素对象
   *
   * @param  集合元素类型
   * @param collection 集合
   * @param filter 过滤器，满足过滤条件的第一个元素将被返回
   * @return 满足过滤条件的第一个元素
   * @since 3.1.0
   */
  public static  T findOne(Iterable collection, Filter filter) {
    if (null != collection) {
      for (T t : collection) {
        if (filter.accept(t)) {
          return t;
        }
      }
    }
    return null;
  }

  /**
   * 查找第一个匹配元素对象

   * 如果集合元素是Map，则比对键和值是否相同，相同则返回

   * 如果为普通Bean，则通过反射比对元素字段名对应的字段值是否相同，相同则返回

   * 如果给定字段值参数是{@code null} 且元素对象中的字段值也为{@code null}则认为相同
   *
   * @param  集合元素类型
   * @param collection 集合，集合元素可以是Bean或者Map
   * @param fieldName 集合元素对象的字段名或map的键
   * @param fieldValue 集合元素对象的字段值或map的值
   * @return 满足条件的第一个元素
   * @since 3.1.0
   */
  public static  T findOneByField(
      Iterable collection, final String fieldName, final Object fieldValue) {
    return findOne(
        collection,
        new Filter() {
          @Override
          public boolean accept(T t) {
            if (t instanceof Map) {
              final Map map = (Map) t;
              final Object value = map.get(fieldName);
              return ObjectUtil.equal(value, fieldValue);
            }

            // 普通Bean
            final Object value = ReflectUtil.getFieldValue(t, fieldName);
            return ObjectUtil.equal(value, fieldValue);
          }
        });
  }

  /**
   * 过滤

   * 过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
   *
   * 
   * 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
   * 2、修改元素对象，返回集合中为修改后的对象
   * 

   *
   * @param  Key类型
   * @param  Value类型
   * @param map Map
   * @param editor 编辑器接口
   * @return 过滤后的Map
   * @see MapUtil#filter(Map, Editor)
   */
  public static  Map filter(Map map, Editor> editor) {
    return MapUtil.filter(map, editor);
  }

  /**
   * 过滤

   * 过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
   *
   * 
   * 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
   * 2、修改元素对象，返回集合中为修改后的对象
   * 

   *
   * @param  Key类型
   * @param  Value类型
   * @param map Map
   * @param filter 编辑器接口
   * @return 过滤后的Map
   * @see MapUtil#filter(Map, Filter)
   * @since 3.1.0
   */
  public static  Map filter(Map map, Filter> filter) {
    return MapUtil.filter(map, filter);
  }

  /**
   * 集合中匹配规则的数量
   *
   * @param  集合元素类型
   * @param iterable {@link Iterable}
   * @param matcher 匹配器，为空则全部匹配
   * @return 匹配数量
   */
  public static  int count(Iterable iterable, Matcher matcher) {
    int count = 0;
    if (null != iterable) {
      for (T t : iterable) {
        if (null == matcher || matcher.match(t)) {
          count++;
        }
      }
    }
    return count;
  }

  // ---------------------------------------------------------------------- isEmpty

  /**
   * 集合是否为空
   *
   * @param collection 集合
   * @return 是否为空
   */
  public static boolean isEmpty(Collection collection) {
    return collection == null || collection.isEmpty();
  }

  /**
   * 如果给定集合为空，返回默认集合
   *
   * @param  集合类型
   * @param  集合元素类型
   * @param collection 集合
   * @param defaultCollection 默认数组
   * @return 非空（empty）的原集合或默认集合
   * @since 4.6.9
   */
  public static , E> T defaultIfEmpty(T collection, T defaultCollection) {
    return isEmpty(collection) ? defaultCollection : collection;
  }

  /**
   * Map是否为空
   *
   * @param map 集合
   * @return 是否为空
   * @see MapUtil#isEmpty(Map)
   */
  public static boolean isEmpty(Map map) {
    return MapUtil.isEmpty(map);
  }

  /**
   * Iterable是否为空
   *
   * @param iterable Iterable对象
   * @return 是否为空
   * @see IterUtil#isEmpty(Iterable)
   */
  public static boolean isEmpty(Iterable iterable) {
    return IterUtil.isEmpty(iterable);
  }

  /**
   * Iterator是否为空
   *
   * @param Iterator Iterator对象
   * @return 是否为空
   * @see IterUtil#isEmpty(Iterator)
   */
  public static boolean isEmpty(Iterator Iterator) {
    return IterUtil.isEmpty(Iterator);
  }

  /**
   * Enumeration是否为空
   *
   * @param enumeration {@link Enumeration}
   * @return 是否为空
   */
  public static boolean isEmpty(Enumeration enumeration) {
    return null == enumeration || false == enumeration.hasMoreElements();
  }

  // ---------------------------------------------------------------------- isNotEmpty

  /**
   * 集合是否为非空
   *
   * @param collection 集合
   * @return 是否为非空
   */
  public static boolean isNotEmpty(Collection collection) {
    return false == isEmpty(collection);
  }

  /**
   * Map是否为非空
   *
   * @param map 集合
   * @return 是否为非空
   * @see MapUtil#isNotEmpty(Map)
   */
  public static boolean isNotEmpty(Map map) {
    return MapUtil.isNotEmpty(map);
  }

  /**
   * Iterable是否为空
   *
   * @param iterable Iterable对象
   * @return 是否为空
   * @see IterUtil#isNotEmpty(Iterable)
   */
  public static boolean isNotEmpty(Iterable iterable) {
    return IterUtil.isNotEmpty(iterable);
  }

  /**
   * Iterator是否为空
   *
   * @param Iterator Iterator对象
   * @return 是否为空
   * @see IterUtil#isNotEmpty(Iterator)
   */
  public static boolean isNotEmpty(Iterator Iterator) {
    return IterUtil.isNotEmpty(Iterator);
  }

  /**
   * Enumeration是否为空
   *
   * @param enumeration {@link Enumeration}
   * @return 是否为空
   */
  public static boolean isNotEmpty(Enumeration enumeration) {
    return null != enumeration && enumeration.hasMoreElements();
  }

  /**
   * 是否包含{@code null}元素
   *
   * @param iterable 被检查的Iterable对象，如果为{@code null} 返回false
   * @return 是否包含{@code null}元素
   * @see IterUtil#hasNull(Iterable)
   * @since 3.0.7
   */
  public static boolean hasNull(Iterable iterable) {
    return IterUtil.hasNull(iterable);
  }

  // ---------------------------------------------------------------------- zip

  /**
   * 映射键值（参考Python的zip()函数）

   * 例如：

   * keys = a,b,c,d

   * values = 1,2,3,4

   * delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4}

   * 如果两个数组长度不同，则只对应最短部分
   *
   * @param keys 键列表
   * @param values 值列表
   * @param delimiter 分隔符
   * @param isOrder 是否有序
   * @return Map
   * @since 3.0.4
   */
  public static Map zip(
      String keys, String values, String delimiter, boolean isOrder) {
    return ArrayUtil.zip(StrUtil.split(keys, delimiter), StrUtil.split(values, delimiter), isOrder);
  }

  /**
   * 映射键值（参考Python的zip()函数），返回Map无序

   * 例如：

   * keys = a,b,c,d

   * values = 1,2,3,4

   * delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4}

   * 如果两个数组长度不同，则只对应最短部分
   *
   * @param keys 键列表
   * @param values 值列表
   * @param delimiter 分隔符
   * @return Map
   */
  public static Map zip(String keys, String values, String delimiter) {
    return zip(keys, values, delimiter, false);
  }

  /**
   * 映射键值（参考Python的zip()函数）

   * 例如：

   * keys = [a,b,c,d]

   * values = [1,2,3,4]

   * 则得到的Map是 {a=1, b=2, c=3, d=4}

   * 如果两个数组长度不同，则只对应最短部分
   *
   * @param  键类型
   * @param  值类型
   * @param keys 键列表
   * @param values 值列表
   * @return Map
   */
  public static  Map zip(Collection keys, Collection values) {
    if (isEmpty(keys) || isEmpty(values)) {
      return null;
    }

    int entryCount = Math.min(keys.size(), values.size());
    final Map map = newHashMap(entryCount);

    final Iterator keyIterator = keys.iterator();
    final Iterator valueIterator = values.iterator();
    while (entryCount > 0) {
      map.put(keyIterator.next(), valueIterator.next());
      entryCount--;
    }

    return map;
  }

  /**
   * 将Entry集合转换为HashMap
   *
   * @param  键类型
   * @param  值类型
   * @param entryIter entry集合
   * @return Map
   * @see IterUtil#toMap(Iterable)
   */
  public static  HashMap toMap(Iterable> entryIter) {
    return IterUtil.toMap(entryIter);
  }

  /**
   * 将数组转换为Map（HashMap），支持数组元素类型为：
   *
   * 
   * Map.Entry
   * 长度大于1的数组（取前两个值），如果不满足跳过此元素
   * Iterable 长度也必须大于1（取前两个值），如果不满足跳过此元素
   * Iterator 长度也必须大于1（取前两个值），如果不满足跳过此元素
   * 

   *
   * 
   * Map<Object, Object> colorMap = CollectionUtil.toMap(new String[][] {{
   *     {"RED", "#FF0000"},
   *     {"GREEN", "#00FF00"},
   *     {"BLUE", "#0000FF"}});
   * 

   *
   * 
参考：commons-lang
   *
   * @param array 数组。元素类型为Map.Entry、数组、Iterable、Iterator
   * @return {@link HashMap}
   * @see MapUtil#of(Object[])
   * @since 3.0.8
   */
  public static HashMap toMap(Object[] array) {
    return MapUtil.of(array);
  }

  /**
   * 将集合转换为排序后的TreeSet
   *
   * @param  集合元素类型
   * @param collection 集合
   * @param comparator 比较器
   * @return treeSet
   */
  public static  TreeSet toTreeSet(Collection collection, Comparator comparator) {
    final TreeSet treeSet = new TreeSet<>(comparator);
    treeSet.addAll(collection);
    return treeSet;
  }

  /**
   * Iterator转换为Enumeration
   *
   * 
Adapt the specified Iterator to the Enumeration interface.
   *
   * @param  集合元素类型
   * @param iter {@link Iterator}
   * @return {@link Enumeration}
   */
  public static  Enumeration asEnumeration(Iterator iter) {
    return new IteratorEnumeration<>(iter);
  }

  /**
   * Enumeration转换为Iterator
   *
   * 
Adapt the specified Enumeration to the Iterator interface
   *
   * @param  集合元素类型
   * @param e {@link Enumeration}
   * @return {@link Iterator}
   * @see IterUtil#asIterator(Enumeration)
   */
  public static  Iterator asIterator(Enumeration e) {
    return IterUtil.asIterator(e);
  }

  /**
   * {@link Iterator} 转为 {@link Iterable}
   *
   * @param  元素类型
   * @param iter {@link Iterator}
   * @return {@link Iterable}
   * @see IterUtil#asIterable(Iterator)
   */
  public static  Iterable asIterable(final Iterator iter) {
    return IterUtil.asIterable(iter);
  }

  /**
   * {@link Iterable}转为{@link Collection}

   * 首先尝试强转，强转失败则构建一个新的{@link ArrayList}
   *
   * @param  集合元素类型
   * @param iterable {@link Iterable}
   * @return {@link Collection} 或者 {@link ArrayList}
   * @since 3.0.9
   */
  public static  Collection toCollection(Iterable iterable) {
    return (iterable instanceof Collection)
        ? (Collection) iterable
        : newArrayList(iterable.iterator());
  }

  /**
   * 行转列，合并相同的键，值合并为列表

   * 将Map列表中相同key的值组成列表做为Map的value

   * 是{@link #toMapList(Map)}的逆方法

   * 比如传入数据：
   *
   * 
   * [
   *  {a: 1, b: 1, c: 1}
   *  {a: 2, b: 2}
   *  {a: 3, b: 3}
   *  {a: 4}
   * ]
   * 

   *
   * 
结果是：
   *
   * 
   * {
   *   a: [1,2,3,4]
   *   b: [1,2,3,]
   *   c: [1]
   * }
   * 

   *
   * @param  键类型
   * @param  值类型
   * @param mapList Map列表
   * @return Map
   * @see MapUtil#toListMap(Iterable)
   */
  public static  Map> toListMap(Iterable> mapList) {
    return MapUtil.toListMap(mapList);
  }

  /**
   * 列转行。将Map中值列表分别按照其位置与key组成新的map。

   * 是{@link #toListMap(Iterable)}的逆方法

   * 比如传入数据：
   *
   * 
   * {
   *   a: [1,2,3,4]
   *   b: [1,2,3,]
   *   c: [1]
   * }
   * 

   *
   * 
结果是：
   *
   * 
   * [
   *  {a: 1, b: 1, c: 1}
   *  {a: 2, b: 2}
   *  {a: 3, b: 3}
   *  {a: 4}
   * ]
   * 

   *
   * @param  键类型
   * @param  值类型
   * @param listMap 列表Map
   * @return Map列表
   * @see MapUtil#toMapList(Map)
   */
  public static  List> toMapList(Map> listMap) {
    return MapUtil.toMapList(listMap);
  }

  /**
   * 将指定对象全部加入到集合中

   * 提供的对象如果为集合类型，会自动转换为目标元素类型

   *
   * @param  元素类型
   * @param collection 被加入的集合
   * @param value 对象，可能为Iterator、Iterable、Enumeration、Array
   * @return 被加入集合
   */
  public static  Collection addAll(Collection collection, Object value) {
    return addAll(collection, value, TypeUtil.getTypeArgument(collection.getClass()));
  }

  /**
   * 将指定对象全部加入到集合中

   * 提供的对象如果为集合类型，会自动转换为目标元素类型

   *
   * @param  元素类型
   * @param collection 被加入的集合
   * @param value 对象，可能为Iterator、Iterable、Enumeration、Array，或者与集合元素类型一致
   * @param elementType 元素类型，为空时，使用Object类型来接纳所有类型
   * @return 被加入集合
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  public static  Collection addAll(Collection collection, Object value, Type elementType) {
    if (null == collection || null == value) {
      return collection;
    }
    if (TypeUtil.isUnknow(elementType)) {
      // 元素类型为空时，使用Object类型来接纳所有类型
      elementType = Object.class;
    }

    Iterator iter;
    if (value instanceof Iterator) {
      iter = (Iterator) value;
    } else if (value instanceof Iterable) {
      iter = ((Iterable) value).iterator();
    } else if (value instanceof Enumeration) {
      iter = new EnumerationIter<>((Enumeration) value);
    } else if (ArrayUtil.isArray(value)) {
      iter = new ArrayIter<>(value);
    } else if (value instanceof CharSequence) {
      // String按照逗号分隔的列表对待
      iter = StrUtil.splitTrim((CharSequence) value, CharUtil.COMMA).iterator();
    } else {
      // 其它类型按照单一元素处理
      iter = CollUtil.newArrayList(value).iterator();
    }

    final ConverterRegistry convert = ConverterRegistry.getInstance();
    while (iter.hasNext()) {
      collection.add((T) convert.convert(elementType, iter.next()));
    }

    return collection;
  }

  /**
   * 加入全部
   *
   * @param  集合元素类型
   * @param collection 被加入的集合 {@link Collection}
   * @param iterator 要加入的{@link Iterator}
   * @return 原集合
   */
  public static  Collection addAll(Collection collection, Iterator iterator) {
    if (null != collection && null != iterator) {
      while (iterator.hasNext()) {
        collection.add(iterator.next());
      }
    }
    return collection;
  }

  /**
   * 加入全部
   *
   * @param  集合元素类型
   * @param collection 被加入的集合 {@link Collection}
   * @param iterable 要加入的内容{@link Iterable}
   * @return 原集合
   */
  public static  Collection addAll(Collection collection, Iterable iterable) {
    return addAll(collection, iterable.iterator());
  }

  /**
   * 加入全部
   *
   * @param  集合元素类型
   * @param collection 被加入的集合 {@link Collection}
   * @param enumeration 要加入的内容{@link Enumeration}
   * @return 原集合
   */
  public static  Collection addAll(Collection collection, Enumeration enumeration) {
    if (null != collection && null != enumeration) {
      while (enumeration.hasMoreElements()) {
        collection.add(enumeration.nextElement());
      }
    }
    return collection;
  }

  /**
   * 加入全部
   *
   * @param  集合元素类型
   * @param collection 被加入的集合 {@link Collection}
   * @param values 要加入的内容数组
   * @return 原集合
   * @since 3.0.8
   */
  public static  Collection addAll(Collection collection, T[] values) {
    if (null != collection && null != values) {
      Collections.addAll(collection, values);
    }
    return collection;
  }

  /**
   * 将另一个列表中的元素加入到列表中，如果列表中已经存在此元素则忽略之
   *
   * @param  集合元素类型
   * @param list 列表
   * @param otherList 其它列表
   * @return 此列表
   */
  public static  List addAllIfNotContains(List list, List otherList) {
    for (T t : otherList) {
      if (false == list.contains(t)) {
        list.add(t);
      }
    }
    return list;
  }

  /**
   * 获取集合中指定下标的元素值，下标可以为负数，例如-1表示最后一个元素

   * 如果元素越界，返回null
   *
   * @param  元素类型
   * @param collection 集合
   * @param index 下标，支持负数
   * @return 元素值
   * @since 4.0.6
   */
  public static  T get(Collection collection, int index) {
    if (null == collection) {
      return null;
    }

    final int size = collection.size();
    if (0 == size) {
      return null;
    }

    if (index < 0) {
      index += size;
    }

    // 检查越界
    if (index >= size) {
      return null;
    }

    if (collection instanceof List) {
      final List list = ((List) collection);
      return list.get(index);
    } else {
      int i = 0;
      for (T t : collection) {
        if (i > index) {
          break;
        } else if (i == index) {
          return t;
        }
        i++;
      }
    }
    return null;
  }

  /**
   * 获取集合中指定多个下标的元素值，下标可以为负数，例如-1表示最后一个元素
   *
   * @param  元素类型
   * @param collection 集合
   * @param indexes 下标，支持负数
   * @return 元素值列表
   * @since 4.0.6
   */
  @SuppressWarnings("unchecked")
  public static  List getAny(Collection collection, int... indexes) {
    final int size = collection.size();
    final ArrayList result = new ArrayList<>();
    if (collection instanceof List) {
      final List list = ((List) collection);
      for (int index : indexes) {
        if (index < 0) {
          index += size;
        }
        result.add(list.get(index));
      }
    } else {
      final Object[] array = collection.toArray();
      for (int index : indexes) {
        if (index < 0) {
          index += size;
        }
        result.add((T) array[index]);
      }
    }
    return result;
  }

  /**
   * 获取集合的第一个元素
   *
   * @param  集合元素类型
   * @param iterable {@link Iterable}
   * @return 第一个元素
   * @see IterUtil#getFirst(Iterable)
   * @since 3.0.1
   */
  public static  T getFirst(Iterable iterable) {
    return IterUtil.getFirst(iterable);
  }

  /**
   * 获取集合的第一个元素
   *
   * @param  集合元素类型
   * @param iterator {@link Iterator}
   * @return 第一个元素
   * @see IterUtil#getFirst(Iterator)
   * @since 3.0.1
   */
  public static  T getFirst(Iterator iterator) {
    return IterUtil.getFirst(iterator);
  }

  /**
   * 获取集合的最后一个元素
   *
   * @param  集合元素类型
   * @param collection {@link Collection}
   * @return 最后一个元素
   * @since 4.1.10
   */
  public static  T getLast(Collection collection) {
    return get(collection, -1);
  }

  /**
   * 获得{@link Iterable}对象的元素类型（通过第一个非空元素判断）
   *
   * @param iterable {@link Iterable}
   * @return 元素类型，当列表为空或元素全部为null时，返回null
   * @see IterUtil#getElementType(Iterable)
   * @since 3.0.8
   */
  public static Class getElementType(Iterable iterable) {
    return IterUtil.getElementType(iterable);
  }

  /**
   * 获得{@link Iterator}对象的元素类型（通过第一个非空元素判断）
   *
   * @param iterator {@link Iterator}
   * @return 元素类型，当列表为空或元素全部为null时，返回null
   * @see IterUtil#getElementType(Iterator)
   * @since 3.0.8
   */
  public static Class getElementType(Iterator iterator) {
    return IterUtil.getElementType(iterator);
  }

  /**
   * 从Map中获取指定键列表对应的值列表

   * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
   *
   * @param  键类型
   * @param  值类型
   * @param map {@link Map}
   * @param keys 键列表
   * @return 值列表
   * @since 3.0.8
   */
  @SuppressWarnings("unchecked")
  public static  ArrayList valuesOfKeys(Map map, K... keys) {
    final ArrayList values = new ArrayList<>();
    for (K k : keys) {
      values.add(map.get(k));
    }
    return values;
  }

  /**
   * 从Map中获取指定键列表对应的值列表

   * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
   *
   * @param  键类型
   * @param  值类型
   * @param map {@link Map}
   * @param keys 键列表
   * @return 值列表
   * @since 3.0.9
   */
  public static  ArrayList valuesOfKeys(Map map, Iterable keys) {
    return valuesOfKeys(map, keys.iterator());
  }

  /**
   * 从Map中获取指定键列表对应的值列表

   * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
   *
   * @param  键类型
   * @param  值类型
   * @param map {@link Map}
   * @param keys 键列表
   * @return 值列表
   * @since 3.0.9
   */
  public static  ArrayList valuesOfKeys(Map map, Iterator keys) {
    final ArrayList values = new ArrayList<>();
    while (keys.hasNext()) {
      values.add(map.get(keys.next()));
    }
    return values;
  }

  // ------------------------------------------------------------------------------------------------- sort

  /**
   * 将多个集合排序并显示不同的段落（分页）

   * 采用{@link BoundedPriorityQueue}实现分页取局部
   *
   * @param  集合元素类型
   * @param pageNo 页码，从1开始计数，0和1效果相同
   * @param pageSize 每页的条目数
   * @param comparator 比较器
   * @param colls 集合数组
   * @return 分页后的段落内容
   */
  @SafeVarargs
  public static  List sortPageAll(
      int pageNo, int pageSize, Comparator comparator, Collection... colls) {
    final List list = new ArrayList<>(pageNo * pageSize);
    for (Collection coll : colls) {
      list.addAll(coll);
    }
    if (null != comparator) {
      Collections.sort(list, comparator);
    }

    return page(pageNo, pageSize, list);
  }

  /**
   * 对指定List分页取值
   *
   * @param  集合元素类型
   * @param pageNo 页码，从1开始计数，0和1效果相同
   * @param pageSize 每页的条目数
   * @param list 列表
   * @return 分页后的段落内容
   * @since 4.1.20
   */
  public static  List page(int pageNo, int pageSize, List list) {
    if (isEmpty(list)) {
      return new ArrayList<>(0);
    }

    int resultSize = list.size();
    // 每页条目数大于总数直接返回所有
    if (resultSize <= pageSize) {
      if (pageNo <= 1) {
        return Collections.unmodifiableList(list);
      } else {
        // 越界直接返回空
        return new ArrayList<>(0);
      }
    }
    final int[] startEnd = PageUtil.transToStartEnd(pageNo, pageSize);
    if (startEnd[1] > resultSize) {
      startEnd[1] = resultSize;
    }
    return list.subList(startEnd[0], startEnd[1]);
  }

  /**
   * 排序集合，排序不会修改原集合
   *
   * @param  集合元素类型
   * @param collection 集合
   * @param comparator 比较器
   * @return treeSet
   */
  public static  List sort(Collection collection, Comparator comparator) {
    List list = new ArrayList<>(collection);
    Collections.sort(list, comparator);
    return list;
  }

  /**
   * 针对List排序，排序会修改原List
   *
   * @param  元素类型
   * @param list 被排序的List
   * @param c {@link Comparator}
   * @return 原list
   * @see Collections#sort(List, Comparator)
   */
  public static  List sort(List list, Comparator c) {
    Collections.sort(list, c);
    return list;
  }

  /**
   * 根据Bean的属性排序
   *
   * @param  元素类型
   * @param collection 集合，会被转换为List
   * @param property 属性名
   * @return 排序后的List
   * @since 4.0.6
   */
  public static  List sortByProperty(Collection collection, String property) {
    return sort(collection, new PropertyComparator<>(property));
  }

  /**
   * 根据Bean的属性排序
   *
   * @param  元素类型
   * @param list List
   * @param property 属性名
   * @return 排序后的List
   * @since 4.0.6
   */
  public static  List sortByProperty(List list, String property) {
    return sort(list, new PropertyComparator<>(property));
  }

  /**
   * 根据汉字的拼音顺序排序
   *
   * @param collection 集合，会被转换为List
   * @return 排序后的List
   * @since 4.0.8
   */
  public static List sortByPinyin(Collection collection) {
    return sort(collection, new PinyinComparator());
  }

  /**
   * 根据汉字的拼音顺序排序
   *
   * @param list List
   * @return 排序后的List
   * @since 4.0.8
   */
  public static List sortByPinyin(List list) {
    return sort(list, new PinyinComparator());
  }

  /**
   * 排序Map
   *
   * @param  键类型
   * @param  值类型
   * @param map Map
   * @param comparator Entry比较器
   * @return {@link TreeMap}
   * @since 3.0.9
   */
  public static  TreeMap sort(Map map, Comparator comparator) {
    final TreeMap result = new TreeMap<>(comparator);
    result.putAll(map);
    return result;
  }

  /**
   * 通过Entry排序，可以按照键排序，也可以按照值排序，亦或者两者综合排序
   *
   * @param  键类型
   * @param  值类型
   * @param entryCollection Entry集合
   * @param comparator {@link Comparator}
   * @return {@link LinkedList}
   * @since 3.0.9
   */
  public static  LinkedHashMap sortToMap(
      Collection> entryCollection, Comparator> comparator) {
    List> list = new LinkedList<>(entryCollection);
    Collections.sort(list, comparator);

    LinkedHashMap result = new LinkedHashMap<>();
    for (Map.Entry entry : list) {
      result.put(entry.getKey(), entry.getValue());
    }
    return result;
  }

  /**
   * 通过Entry排序，可以按照键排序，也可以按照值排序，亦或者两者综合排序
   *
   * @param  键类型
   * @param  值类型
   * @param map 被排序的Map
   * @param comparator {@link Comparator}
   * @return {@link LinkedList}
   * @since 3.0.9
   */
  public static  LinkedHashMap sortByEntry(
      Map map, Comparator> comparator) {
    return sortToMap(map.entrySet(), comparator);
  }

  /**
   * 将Set排序（根据Entry的值）
   *
   * @param  键类型
   * @param  值类型
   * @param collection 被排序的{@link Collection}
   * @return 排序后的Set
   */
  public static  List> sortEntryToList(Collection> collection) {
    List> list = new LinkedList<>(collection);
    Collections.sort(
        list,
        new Comparator>() {

          @SuppressWarnings({"rawtypes", "unchecked"})
          @Override
          public int compare(Entry o1, Entry o2) {
            V v1 = o1.getValue();
            V v2 = o2.getValue();

            if (v1 instanceof Comparable) {
              return ((Comparable) v1).compareTo(v2);
            } else {
              return v1.toString().compareTo(v2.toString());
            }
          }
        });
    return list;
  }

  // ------------------------------------------------------------------------------------------------- forEach

  /**
   * 循环遍历 {@link Iterator}，使用{@link Consumer} 接受遍历的每条数据，并针对每条数据做处理
   *
   * @param  集合元素类型
   * @param iterator {@link Iterator}
   * @param consumer {@link Consumer} 遍历的每条数据处理器
   */
  public static  void forEach(Iterator iterator, Consumer consumer) {
    int index = 0;
    while (iterator.hasNext()) {
      consumer.accept(iterator.next(), index);
      index++;
    }
  }

  /**
   * 循环遍历 {@link Enumeration}，使用{@link Consumer} 接受遍历的每条数据，并针对每条数据做处理
   *
   * @param  集合元素类型
   * @param enumeration {@link Enumeration}
   * @param consumer {@link Consumer} 遍历的每条数据处理器
   */
  public static  void forEach(Enumeration enumeration, Consumer consumer) {
    int index = 0;
    while (enumeration.hasMoreElements()) {
      consumer.accept(enumeration.nextElement(), index);
      index++;
    }
  }

  /**
   * 循环遍历Map，使用{@link KVConsumer} 接受遍历的每条数据，并针对每条数据做处理
   *
   * @param  Key类型
   * @param  Value类型
   * @param map {@link Map}
   * @param kvConsumer {@link KVConsumer} 遍历的每条数据处理器
   */
  public static  void forEach(Map map, KVConsumer kvConsumer) {
    int index = 0;
    for (Entry entry : map.entrySet()) {
      kvConsumer.accept(entry.getKey(), entry.getValue(), index);
      index++;
    }
  }

  /**
   * 分组，按照{@link Hash}接口定义的hash算法，集合中的元素放入hash值对应的子列表中
   *
   * @param  元素类型
   * @param collection 被分组的集合
   * @param hash Hash值算法，决定元素放在第几个分组的规则
   * @return 分组后的集合
   */
  public static  List> group(Collection collection, Hash hash) {
    final List> result = new ArrayList<>();
    if (isEmpty(collection)) {
      return result;
    }
    if (null == hash) {
      // 默认hash算法，按照元素的hashCode分组
      hash =
          new Hash() {
            @Override
            public int hash(T t) {
              return null == t ? 0 : t.hashCode();
            }
          };
    }

    int index;
    List subList;
    for (T t : collection) {
      index = hash.hash(t);
      if (result.size() - 1 < index) {
        while (result.size() - 1 < index) {
          result.add(null);
        }
        result.set(index, newArrayList(t));
      } else {
        subList = result.get(index);
        if (null == subList) {
          result.set(index, newArrayList(t));
        } else {
          subList.add(t);
        }
      }
    }
    return result;
  }

  /**
   * 根据元素的指定字段名分组，非Bean都放在第一个分组中
   *
   * @param  元素类型
   * @param collection 集合
   * @param fieldName 元素Bean中的字段名，非Bean都放在第一个分组中
   * @return 分组列表
   */
  public static  List> groupByField(Collection collection, final String fieldName) {
    return group(
        collection,
        new Hash() {
          private List fieldNameList = new ArrayList<>();

          @Override
          public int hash(T t) {
            if (null == t || false == BeanUtil.isBean(t.getClass())) {
              // 非Bean放在同一子分组中
              return 0;
            }
            final Object value = ReflectUtil.getFieldValue(t, fieldName);
            int hash = fieldNameList.indexOf(value);
            if (hash < 0) {
              fieldNameList.add(value);
              return fieldNameList.size() - 1;
            } else {
              return hash;
            }
          }
        });
  }

  /**
   * 反序给定List，会在原List基础上直接修改
   *
   * @param  元素类型
   * @param list 被反转的List
   * @return 反转后的List
   * @since 4.0.6
   */
  public static  List reverse(List list) {
    Collections.reverse(list);
    return list;
  }

  /**
   * 反序给定List，会创建一个新的List，原List数据不变
   *
   * @param  元素类型
   * @param list 被反转的List
   * @return 反转后的List
   * @since 4.0.6
   */
  public static  List reverseNew(List list) {
    final List list2 = ObjectUtil.clone(list);
    return reverse(list2);
  }

  /**
   * 设置或增加元素。当index小于List的长度时，替换指定位置的值，否则在尾部追加
   *
   * @param  元素类型
   * @param list List列表
   * @param index 位置
   * @param element 新元素
   * @return 原List
   * @since 4.1.2
   */
  public static  List setOrAppend(List list, int index, T element) {
    if (index < list.size()) {
      list.set(index, element);
    } else {
      list.add(element);
    }
    return list;
  }

  /**
   * 获取指定Map列表中所有的Key
   *
   * @param  键类型
   * @param mapCollection Map列表
   * @return key集合
   * @since 4.5.12
   */
  public static  Set keySet(Collection> mapCollection) {
    if (isEmpty(mapCollection)) {
      return new HashSet<>();
    }
    final HashSet set = new HashSet<>(mapCollection.size() * 16);
    for (Map map : mapCollection) {
      set.addAll(map.keySet());
    }

    return set;
  }

  /**
   * 获取指定Map列表中所有的Value
   *
   * @param  值类型
   * @param mapCollection Map列表
   * @return Value集合
   * @since 4.5.12
   */
  public static  List values(Collection> mapCollection) {
    final List values = new ArrayList<>();
    for (Map map : mapCollection) {
      values.addAll(map.values());
    }

    return values;
  }

  /**
   * 取最大值
   *
   * @param  元素类型
   * @param coll 集合
   * @return 最大值
   * @see Collections#max(Collection)
   * @since 4.6.5
   */
  public static > T max(Collection coll) {
    return Collections.max(coll);
  }

  /**
   * 取最大值
   *
   * @param  元素类型
   * @param coll 集合
   * @return 最大值
   * @see Collections#min(Collection)
   * @since 4.6.5
   */
  public static > T min(Collection coll) {
    return Collections.min(coll);
  }

  // ----------------------------------------------------------------------------------------------
  // Interface start

  /**
   * 针对一个参数做相应的操作
   *
   * @param  处理参数类型
   * @author Looly
   */
  public interface Consumer {
    /**
     * 接受并处理一个参数
     *
     * @param value 参数值
     * @param index 参数在集合中的索引
     */
    void accept(T value, int index);
  }

  /**
   * 针对两个参数做相应的操作，例如Map中的KEY和VALUE
   *
   * @param  KEY类型
   * @param  VALUE类型
   * @author Looly
   */
  public interface KVConsumer {
    /**
     * 接受并处理一对参数
     *
     * @param key 键
     * @param value 值
     * @param index 参数在集合中的索引
     */
    void accept(K key, V value, int index);
  }

  /**
   * Hash计算接口
   *
   * @param  被计算hash的对象类型
   * @author looly
   * @since 3.2.2
   */
  public interface Hash {
    /**
     * 计算Hash值
     *
     * @param t 对象
     * @return hash
     */
    int hash(T t);
  }
  // ----------------------------------------------------------------------------------------------
  // Interface end
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy