程序包 me.codeplayer.util

类 CollectionUtil

  • public abstract class CollectionUtil
extends Object
    List、Set、Map等常见集合数据操作的工具类
    作者:
    Ready

    • 方法概要

      所有方法 静态方法 具体方法 
      修饰符和类型 方法 说明
      static <E> Collection<E> addAll​(Collection<E> target, E... elements)
      将可变参数形式的键值数组添加到一个Map集合中
      static <E> Collection<E> addAll​(Collection<E> target, Predicate<? super E> filter, E... elements)
      将可变参数形式的键值数组添加到一个 Map 集合中
      static <K,​V>
      Map<K,​V>      		 addAll​(Map<K,​V> map, Object... kvPairs)
      将可变参数形式的键值数组添加到一个 Map 集合中
      protected static void checkPairs​(Object... pairs)  
      static <T> T findFirst​(Collection<T> range, Predicate<? super T> filter)
      遍历集合，并使用指定的过滤器进行检测，返回遍历到的第一个符合条件的元素
      static <T> T getAny​(Collection<T> range)
      遍历集合，并使用指定的过滤器进行检测，返回遍历到的第一个元素
      static <T,​R>
      R[]      		 mapField​(Collection<T> list, Class<R> fieldType, Function<? super T,​? extends R> mapper)
      依次将集合中每个元素进行指定的映射，。
      static int mapInitialCapacity​(int realCapacity)
      根据真实的元素个数和默认的负载因子，计算 Map 集合合理的容量初始值
      static int mapInitialCapacity​(int realCapacity, float loadFactor)
      根据真实的元素个数和负载因子，计算 Map 集合合理的容量初始值
      static <K,​V>
      V[]      		 mapValues​(Map<K,​V> map, Class<V> valueClass, K... keys)
      获取Map集合中指定的多个键的值，并以数组的形式依次返回。
      static <E,​S extends Collection<E>>
      S      		 of​(Supplier<S> newList, E... elements)
      根据可变参数形式的键值数组构造一个集合
      static <E> ArrayList<E> ofArrayList​(E... elements)
      根据可变参数形式的键值数组构造一个 ArrayList 集合
      static <K,​V>
      HashMap<K,​V>      		 ofHashMap​(Object... elements)
      根据可变参数形式的键值数组构造一个 Map 集合
      static <E> HashSet<E> ofHashSet​(E... elements)
      根据可变参数形式的键值数组构造一个 HashSet 集合
      static <E,​S extends Set<E>>
      S      		 ofSet​(IntFunction<S> newSet, E... elements)
      根据可变参数形式的键值数组构造一个 Set 集合
      static <E,​S extends Collection<E>>
      S      		 ofSize​(IntFunction<S> newList, E... elements)
      根据可变参数形式的键值数组构造一个集合
      static <E,​K,​V>
      HashMap<K,​V>      		 toHashMap​(Iterable<E> items, Function<? super E,​K> keyMapper, Function<? super E,​V> valueMapper)
      将指定的数据集合转为 HashMap 集合
      static <K,​V>
      HashMap<K,​V>      		 toHashMap​(Iterable<V> items, Function<? super V,​K> keyMapper)
      将指定的数据集合转为 HashMap 集合
      static <E,​K,​V,​M extends Map<K,​V>>
      M      		 toMap​(IntFunction<M> newMap, Iterable<E> items, Function<? super E,​K> keyMapper, Function<? super E,​V> valueMapper)
      将指定的数据集合转为 Map 集合
      static <K,​V,​M extends Map<K,​V>>
      M      		 toMap​(IntFunction<M> newMap, Iterable<V> items, Function<? super V,​K> keyMapper)
      将指定的数据集合转为 Map 集合
      static <K,​V,​M extends Map<K,​V>>
      M      		 toMap​(IntFunction<M> newMap, Object... elements)
      根据可变参数形式的键值数组构造一个 Map 集合

    • 构造器详细资料

      • CollectionUtil

        public CollectionUtil()

    • 方法详细资料

      • checkPairs

        protected static void checkPairs​(Object... pairs)

      • mapInitialCapacity

        public static int mapInitialCapacity​(int realCapacity,
                                     float loadFactor)
        根据真实的元素个数和负载因子，计算 Map 集合合理的容量初始值
        参数:
        realCapacity - 真实的元素个数
        loadFactor - 负载因子

      • mapInitialCapacity

        public static int mapInitialCapacity​(int realCapacity)
        根据真实的元素个数和默认的负载因子，计算 Map 集合合理的容量初始值
        参数:
        realCapacity - 真实的元素个数

      • addAll

        public static <E> Collection<E> addAll​(Collection<E> target,
                                       @Nullable
                                       Predicate<? super E> filter,
                                       E... elements)
        将可变参数形式的键值数组添加到一个 Map 集合中
        参数:
        target - 指定的 Collection 集合
        filter - 如果指定了该数组元素过滤器，则只有过滤结果为 true 的才会被添加
        elements - 可变参数形式的元素数组

      • addAll

        public static <E> Collection<E> addAll​(Collection<E> target,
                                       E... elements)
        将可变参数形式的键值数组添加到一个Map集合中
        参数:
        target - 指定的 Collection 集合
        elements - 可变参数形式的元素数组

      • addAll

        public static <K,​V> Map<K,​V> addAll​(Map<K,​V> map,
                                                Object... kvPairs)
        将可变参数形式的键值数组添加到一个 Map 集合中
        参数:
        map - 指定的Map集合
        kvPairs - 可变参数形式的键值数组，必须是K1, V1, K2, V2, K3, V3...这种形式

      • ofSize

        public static <E,​S extends Collection<E>> S ofSize​(IntFunction<S> newList,
                                                         E... elements)
        根据可变参数形式的键值数组构造一个集合
        参数:
        newList - Collection 构造器，int 类型的参数为 Collection 构造方法的 initialCapacity 参数
        elements - 可变参数形式的元素数组

      • of

        public static <E,​S extends Collection<E>> S of​(Supplier<S> newList,
                                                     E... elements)
        根据可变参数形式的键值数组构造一个集合
        参数:
        newList - Collection 构造器
        elements - 可变参数形式的元素数组

      • ofSet

        public static <E,​S extends Set<E>> S ofSet​(IntFunction<S> newSet,
                                                 E... elements)
        根据可变参数形式的键值数组构造一个 Set 集合
        参数:
        newSet - Set 构造器，int 类型的参数为 Set 构造方法的 initialCapacity 参数
        elements - 可变参数形式的元素数组

      • ofHashSet

        public static <E> HashSet<E> ofHashSet​(E... elements)
        根据可变参数形式的键值数组构造一个 HashSet 集合
        参数:
        elements - 可变参数形式的元素数组

      • ofArrayList

        public static <E> ArrayList<E> ofArrayList​(E... elements)
        根据可变参数形式的键值数组构造一个 ArrayList 集合
        参数:
        elements - 可变参数形式的元素数组

      • toMap

        public static <K,​V,​M extends Map<K,​V>> M toMap​(IntFunction<M> newMap,
                                                                 Object... elements)
        根据可变参数形式的键值数组构造一个 Map 集合
        参数:
        newMap - Map 构造器，int 参数为 Map 构造方法的 initialCapacity 参数
        elements - 可变参数形式的元素数组

      • ofHashMap

        public static <K,​V> HashMap<K,​V> ofHashMap​(Object... elements)
        根据可变参数形式的键值数组构造一个 Map 集合
        参数:
        elements - 可变参数形式的元素数组

      • toMap

        public static <E,​K,​V,​M extends Map<K,​V>> M toMap​(IntFunction<M> newMap,
                                                                         Iterable<E> items,
                                                                         Function<? super E,​K> keyMapper,
                                                                         Function<? super E,​V> valueMapper)
        将指定的数据集合转为 Map 集合
        参数:
        newMap - Map 构造器，int 参数为 Map 构造方法的 initialCapacity 参数
        items - 需要放入 Map 集合的数据集合
        keyMapper - Map 的 Entry.key 转换器
        valueMapper - Map 的 Entry.value 转换器

      • toHashMap

        public static <E,​K,​V> HashMap<K,​V> toHashMap​(Iterable<E> items,
                                                               Function<? super E,​K> keyMapper,
                                                               Function<? super E,​V> valueMapper)
        将指定的数据集合转为 HashMap 集合
        参数:
        items - 需要放入 Map 集合的数据集合
        keyMapper - Map 的 Entry.key 转换器
        valueMapper - Map 的 Entry.value 转换器

      • toMap

        public static <K,​V,​M extends Map<K,​V>> M toMap​(IntFunction<M> newMap,
                                                                 Iterable<V> items,
                                                                 Function<? super V,​K> keyMapper)
        将指定的数据集合转为 Map 集合
        参数:
        newMap - Map 构造器，int 参数为 Map 构造方法的 initialCapacity 参数
        items - 需要放入 Map 集合的数据集合
        keyMapper - Map 的 Entry.key 转换器

      • toHashMap

        public static <K,​V> HashMap<K,​V> toHashMap​(Iterable<V> items,
                                                       Function<? super V,​K> keyMapper)
        将指定的数据集合转为 HashMap 集合
        参数:
        items - 需要放入 Map 集合的数据集合
        keyMapper - Map 的 Entry.key 转换器

      • mapValues

        public static <K,​V> V[] mapValues​(Map<K,​V> map,
                                        Class<V> valueClass,
                                        K... keys)
        获取Map集合中指定的多个键的值，并以数组的形式依次返回。如果集合中没有指定的键，则数组对应位置的值为null
        参数:
        map - 指定的Map集合
        valueClass - 数组的组件类型
        keys - 指定的键数组
        从以下版本开始:
        0.3.1

      • findFirst

        public static <T> T findFirst​(Collection<T> range,
                              @Nullable
                              Predicate<? super T> filter)
        遍历集合，并使用指定的过滤器进行检测，返回遍历到的第一个符合条件的元素
        参数:
        filter - 如果为 null，则默认为 true
        从以下版本开始:
        2.8.0

      • getAny

        public static <T> T getAny​(Collection<T> range)
        遍历集合，并使用指定的过滤器进行检测，返回遍历到的第一个元素
        从以下版本开始:
        3.0.0

      • mapField

        public static <T,​R> R[] mapField​(Collection<T> list,
                                       Class<R> fieldType,
                                       Function<? super T,​? extends R> mapper)
        依次将集合中每个元素进行指定的映射，。并返回映射后的数组
        参数:
        list - 集合
        fieldType - 映射后的字段类型
        mapper - 映射转换器