CollectionKit (toolset 1.4.RELEASE API)

java.lang.Object
- net.lulihu.ObjectKit.CollectionKit

public class CollectionKit
extends Object

集合相关工具类，包括数组

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static <T> T[]`	`addAll(T[]... arrays)` 将多个数组合并在一起忽略null的数组
`static <T> T[]`	`append(T[] buffer, T newElement)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`static <T> List<T>`	`clone(List<T> array)` 克隆数组
`static <T> T[]`	`clone(T[] array)` 克隆数组
`static <T> boolean`	`contains(T[] array, T value)` 数组中是否包含元素
`static boolean`	`isArray(Object obj)` 判定给定对象是否为数组类型
`static boolean`	`isEmpty(Collection<?> collection)` 集合是否为空
`static <V> Collection<V>`	`isEmpty(Collection<V> collection, CollectionConsumption<V> accept)` 如果集合为空则执行表达式返回结果，如果集合不为空，则直接返回
`static boolean`	`isEmpty(Iterable<?> iterable)` 集合是否为空
`static <T> boolean`	`isEmpty(T[] array)` 数组是否为空
`static boolean`	`isNotEmpty(Collection<?> collection)` 集合是否为非空
`static <T> boolean`	`isNotEmpty(T[] array)` 数组是否为非空
`static <T> String`	`join(Iterable<T> collection, String conjunction)` 以 conjunction 为分隔符将集合转换为字符串
`static <T> String`	`join(String conjunction, Iterable<T> collection, ConsumerResult<T,String> consumption)` 以 conjunction 为分隔符将集合转换为字符串
`static <T> String`	`join(String conjunction, T... array)` 以 conjunction 为分隔符将数组转换为字符串
`static <E,T> List<T>`	`listToList(E[] list, ConsumerResult<E,T> consumer)` 数组取字段封装为另一个集合
`static <E,T> List<T>`	`listToList(Iterable<E> list, ConsumerResult<E,T> consumer)` 集合取字段封装为另一个集合
`static <T> T[]`	`newArray(Class<?> componentType, int newSize)` 新建一个空数组
`static <T> ArrayList<T>`	`newArrayList()` 新建一个ArrayList
`static <T> ArrayList<T>`	`newArrayList(T... values)` 新建一个ArrayList
`static <T> HashSet<T>`	`newHashSet()` 新建一个HashSet
`static <T> HashSet<T>`	`newHashSet(T... ts)` 新建一个HashSet
`static <T> List<T>`	`popPart(Deque<T> surplus, int partSize)` 切取部分数据
`static <T> List<T>`	`popPart(Stack<T> stack, int partSize)` 切取部分数据
`static int[]`	`range(int excludedEnd)` 生成一个数字列表自动判定正序反序
`static int[]`	`range(int includedStart, int excludedEnd)` 生成一个数字列表自动判定正序反序
`static int[]`	`range(int includedStart, int excludedEnd, int step)` 生成一个数字列表自动判定正序反序
`static <T> T[]`	`resize(T[] buffer, int newSize)` 生成一个新的重新设置大小的数组新数组的类型为原数组的类型
`static <T> T[]`	`resize(T[] buffer, int newSize, Class<?> componentType)` 生成一个新的重新设置大小的数组
`static <T> List<T>`	`sort(Collection<T> collection, Comparator<T> comparator)` 排序集合
`static List<Map.Entry<Long,Long>>`	`sortEntrySetToList(Set<Map.Entry<Long,Long>> set)` 将Set排序（根据Entry的值）
`static <T> List<T>`	`sub(Collection<T> list, int start, int end)` 截取集合的部分
`static <T> List<T>`	`sub(List<T> list, int start, int end)` 截取数组的部分
`static String`	`toString(Object obj)` 数组或集合转String
`static <T> TreeSet<T>`	`toTreeSet(Collection<T> collection, Comparator<T> comparator)` 将集合转换为排序后的TreeSet
`static Boolean[]`	`wrap(boolean... values)` 将基本类型数组包装为包装类型
`static Byte[]`	`wrap(byte... values)` 将基本类型数组包装为包装类型
`static Character[]`	`wrap(char... values)` 将基本类型数组包装为包装类型
`static Double[]`	`wrap(double... values)` 将基本类型数组包装为包装类型
`static Float[]`	`wrap(float... values)` 将基本类型数组包装为包装类型
`static Integer[]`	`wrap(int... values)` 将基本类型数组包装为包装类型
`static Integer[]`	`wrap(List<Integer> values)` 集合转数组
`static Long[]`	`wrap(long... values)` 将基本类型数组包装为包装类型
`static Short[]`	`wrap(short... values)` 将基本类型数组包装为包装类型
`static <T> List<T>`	`wrap(T... values)` 数组转集合
`static Object[]`	`wrapList(List<Object> values)` 集合转数组
`static String[]`	`wrapStr(List<String> values)` 集合转数组
`static <T,K> Map<T,K>`	`zip(Collection<T> keys, Collection<K> values)` 映射键值（参考Python的zip()函数）例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
`static Map<String,String>`	`zip(String keys, String values, String delimiter)` 映射键值（参考Python的zip()函数）例如： keys = a,b,c,d values = 1,2,3,4 delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
`static <T,K> Map<T,K>`	`zip(T[] keys, K[] values)` 映射键值（参考Python的zip()函数）例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细资料
  - listToList
```
public static <E,T> List<T> listToList(E[] list,
                                       ConsumerResult<E,T> consumer)
```
    数组取字段封装为另一个集合
    
    类型参数:
    
    E - 泛型
    
    参数:
    
    list - 集合对象
    
    consumer - 表达式执行者
    
    返回:
    
    返回拼接结果
  - listToList
```
public static <E,T> List<T> listToList(Iterable<E> list,
                                       ConsumerResult<E,T> consumer)
```
    集合取字段封装为另一个集合
    
    类型参数:
    
    E - 泛型
    
    参数:
    
    list - 集合对象
    
    consumer - 表达式执行者
    
    返回:
    
    返回拼接结果
  - join
```
public static <T> String join(Iterable<T> collection,
                              String conjunction)
```
    以 conjunction 为分隔符将集合转换为字符串
    
    类型参数:
    
    T - 被处理的集合
    
    参数:
    
    collection - 集合
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static <T> String join(String conjunction,
                              Iterable<T> collection,
                              ConsumerResult<T,String> consumption)
```
    以 conjunction 为分隔符将集合转换为字符串
    
    类型参数:
    
    T - 被处理的集合
    
    参数:
    
    conjunction - 分隔符
    
    collection - 集合
    
    consumption - 取值表达式
    
    返回:
    
    连接后的字符串
  - join
```
public static <T> String join(String conjunction,
                              T... array)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    类型参数:
    
    T - 被处理的集合
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - sortEntrySetToList
```
public static List<Map.Entry<Long,Long>> sortEntrySetToList(Set<Map.Entry<Long,Long>> set)
```
    将Set排序（根据Entry的值）
    
    参数:
    
    set - 被排序的Set
    
    返回:
    
    排序后的Set
  - popPart
```
public static <T> List<T> popPart(Stack<T> stack,
                                  int partSize)
```
    切取部分数据
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    stack - 原数据
    
    partSize - 每部分数据的长度
    
    返回:
    
    切取出的数据或null
  - popPart
```
public static <T> List<T> popPart(Deque<T> surplus,
                                  int partSize)
```
    切取部分数据
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    surplus - 原数据
    
    partSize - 每部分数据的长度
    
    返回:
    
    切取出的数据或null
  - newHashSet
```
public static <T> HashSet<T> newHashSet()
```
    新建一个HashSet
    
    返回:
    
    HashSet对象
  - newHashSet
```
@SafeVarargs
public static <T> HashSet<T> newHashSet(T... ts)
```
    新建一个HashSet
    
    返回:
    
    HashSet对象
  - newArrayList
```
public static <T> ArrayList<T> newArrayList()
```
    新建一个ArrayList
    
    返回:
    
    ArrayList对象
  - newArrayList
```
@SafeVarargs
public static <T> ArrayList<T> newArrayList(T... values)
```
    新建一个ArrayList
    
    返回:
    
    ArrayList对象
  - append
```
public static <T> T[] append(T[] buffer,
                             T newElement)
```
    将新元素添加到已有数组中
    添加新元素会生成一个新的数组，不影响原数组
    
    参数:
    
    buffer - 已有数组
    
    newElement - 新元素
    
    返回:
    
    新数组
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize,
                             Class<?> componentType)
```
    生成一个新的重新设置大小的数组
    
    参数:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    componentType - 数组元素类型
    
    返回:
    
    调整后的新数组
  - newArray
```
public static <T> T[] newArray(Class<?> componentType,
                               int newSize)
```
    新建一个空数组
    
    参数:
    
    componentType - 元素类型
    
    newSize - 大小
    
    返回:
    
    空数组
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize)
```
    生成一个新的重新设置大小的数组
    新数组的类型为原数组的类型
    
    参数:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    返回:
    
    调整后的新数组
  - addAll
```
@SafeVarargs
public static <T> T[] addAll(T[]... arrays)
```
    将多个数组合并在一起
    忽略null的数组
    
    参数:
    
    arrays - 数组集合
    
    返回:
    
    合并后的数组
  - clone
```
public static <T> List<T> clone(List<T> array)
```
    克隆数组
    
    参数:
    
    array - 被克隆的数组
    
    返回:
    
    新数组
  - clone
```
public static <T> T[] clone(T[] array)
```
    克隆数组
    
    参数:
    
    array - 被克隆的数组
    
    返回:
    
    新数组
  - range
```
public static int[] range(int excludedEnd)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    
    excludedEnd - 结束的数字（不包含）
    
    返回:
    
    数字列表
  - range
```
public static int[] range(int includedStart,
                          int excludedEnd)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    
    includedStart - 开始的数字（包含）
    
    excludedEnd - 结束的数字（不包含）
    
    返回:
    
    数字列表
  - range
```
public static int[] range(int includedStart,
                          int excludedEnd,
                          int step)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    
    includedStart - 开始的数字（包含）
    
    excludedEnd - 结束的数字（不包含）
    
    step - 步进
    
    返回:
    
    数字列表
  - sub
```
public static <T> List<T> sub(List<T> list,
                              int start,
                              int end)
```
    截取数组的部分
    
    参数:
    
    list - 被截取的数组
    
    start - 开始位置（包含）
    
    end - 结束位置（不包含）
    
    返回:
    
    截取后的数组，当开始位置超过最大时，返回null
  - sub
```
public static <T> List<T> sub(Collection<T> list,
                              int start,
                              int end)
```
    截取集合的部分
    
    参数:
    
    list - 被截取的数组
    
    start - 开始位置（包含）
    
    end - 结束位置（不包含）
    
    返回:
    
    截取后的数组，当开始位置超过最大时，返回null
  - isEmpty
```
public static <T> boolean isEmpty(T[] array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static <T> boolean isNotEmpty(T[] array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isEmpty
```
public static boolean isEmpty(Collection<?> collection)
```
    集合是否为空
    
    参数:
    
    collection - 集合
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(Iterable<?> iterable)
```
    集合是否为空
    
    参数:
    
    iterable - 集合
    
    返回:
    
    是否为空
  - isEmpty
```
public static <V> Collection<V> isEmpty(Collection<V> collection,
                                        CollectionConsumption<V> accept)
```
    如果集合为空则执行表达式返回结果，如果集合不为空，则直接返回
    
    参数:
    
    collection - 集合
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(Collection<?> collection)
```
    集合是否为非空
    
    参数:
    
    collection - 集合
    
    返回:
    
    是否为非空
  - zip
```
public static <T,K> Map<T,K> zip(T[] keys,
                                 K[] values)
```
    映射键值（参考Python的zip()函数）
    例如：
    keys = [a,b,c,d]
    values = [1,2,3,4]
    则得到的Map是 {a=1, b=2, c=3, d=4}
    如果两个数组长度不同，则只对应最短部分
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    返回:
    
    Map
  - zip
```
public static Map<String,String> zip(String keys,
                                     String values,
                                     String delimiter)
```
    映射键值（参考Python的zip()函数）
    例如：
    keys = a,b,c,d
    values = 1,2,3,4
    delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4}
    如果两个数组长度不同，则只对应最短部分
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    返回:
    
    Map
  - zip
```
public static <T,K> Map<T,K> zip(Collection<T> keys,
                                 Collection<K> values)
```
    映射键值（参考Python的zip()函数）
    例如：
    keys = [a,b,c,d]
    values = [1,2,3,4]
    则得到的Map是 {a=1, b=2, c=3, d=4}
    如果两个数组长度不同，则只对应最短部分
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    返回:
    
    Map
  - contains
```
public static <T> boolean contains(T[] array,
                                   T value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
  - toTreeSet
```
public static <T> TreeSet<T> toTreeSet(Collection<T> collection,
                                       Comparator<T> comparator)
```
    将集合转换为排序后的TreeSet
    
    参数:
    
    collection - 集合
    
    comparator - 比较器
    
    返回:
    
    treeSet
  - sort
```
public static <T> List<T> sort(Collection<T> collection,
                               Comparator<T> comparator)
```
    排序集合
    
    参数:
    
    collection - 集合
    
    comparator - 比较器
    
    返回:
    
    treeSet
  - wrap
```
public static <T> List<T> wrap(T... values)
```
    数组转集合
    
    参数:
    
    values - 数组
    
    返回:
    
    同样的集合
  - wrapList
```
public static Object[] wrapList(List<Object> values)
```
    集合转数组
    
    参数:
    
    values - 数组
    
    返回:
    
    同样的数组
  - wrapStr
```
public static String[] wrapStr(List<String> values)
```
    集合转数组
    
    参数:
    
    values - 数组
    
    返回:
    
    同样的集合
  - wrap
```
public static Integer[] wrap(List<Integer> values)
```
    集合转数组
    
    参数:
    
    values - 数组
    
    返回:
    
    同样的集合
  - wrap
```
public static Integer[] wrap(int... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - wrap
```
public static Long[] wrap(long... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - wrap
```
public static Character[] wrap(char... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - wrap
```
public static Byte[] wrap(byte... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - wrap
```
public static Short[] wrap(short... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - wrap
```
public static Float[] wrap(float... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - wrap
```
public static Double[] wrap(double... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - wrap
```
public static Boolean[] wrap(boolean... values)
```
    将基本类型数组包装为包装类型
    
    参数:
    
    values - 基本类型数组
    
    返回:
    
    包装类型数组
  - isArray
```
public static boolean isArray(Object obj)
```
    判定给定对象是否为数组类型
    
    参数:
    
    obj - 对象
    
    返回:
    
    是否为数组类型
  - toString
```
public static String toString(Object obj)
```
    数组或集合转String
    
    参数:
    
    obj - 集合或数组对象
    
    返回:
    
    数组字符串，与集合转字符串格式相同

类 CollectionKit

方法概要

从类继承的方法 java.lang.Object

方法详细资料

listToList

listToList

join

join

join

sortEntrySetToList

popPart

popPart

newHashSet

newHashSet

newArrayList

newArrayList

append

resize

newArray

resize

addAll

clone

clone

range

range

range

sub

sub

isEmpty

isNotEmpty

isEmpty

isEmpty

isEmpty

isNotEmpty

zip

zip

zip

contains

toTreeSet

sort

wrap

wrapList

wrapStr

wrap

wrap

wrap

wrap

wrap

wrap

wrap

wrap

wrap

isArray

toString