Property Detail

• static Closure sequenceSwapper

  用于给行如“n.n.n”这种序号排序的转换器。

  用于方法 sort 的参数 elementSwapper

• @Deprecated static Closure sortorderSwapper

Method Detail

• static Collection addToMapCollectionValues(Map<Object, Collection> target, Class collectionClazz, Object key, Object value)

  将元素添加到 Map 的值列表中

• static List<Map> collect(Object objects, List<String> keys, List<String> properties = keys)

  收集多个对象的属性，并返回一个新的 Map 列表

  例如：collect(Employee.list(), ['id', 'name'], ['id', 'code'])。
  等同于 Employee.list().collect{ [id: it.id, name: it.code] }。

  Parameters:

  objects - 对象集合，也可以是一个 Map 集合

  keys - 返回的 Map 元素的键

  properties - 返回的 Map 元素的值对应的对象属性名，和 keys 一一对应；默认等于 keys。

• static List collect(Object objects, int index)

  根据下标，收集二维集合的某个属性，并返回一个新的列表

• static List combineSorted(List left, List right, Comparator comparator = null)

  合并两个已排序、除重的列表，并除重

  Parameters:

  comparator - 元素大小比较器，如 {Map a, b -> a.get(x) <=> b.get(x)} as Comparator

• static Object find(Object entities, String property, Object value)

  从集合中根据属性查找元素，比find闭包性能提升2.5+倍

  Parameters:

  entities - 实体对象集或数组

  property - 属性名称，如果为null，则表示直接用集合元素进行比较

  value -

       属性值。如果是集合或数组，则包含属性值的，也认为是查找成功。
       如 find(list, "name", ["name1", "name2"])，会返回name属性为name1或name2的元素。
   

• static Object find(Object entities, List<String> properties, List values)

  从集合中根据属性查找元素，比find闭包性能提升2.5+倍

  Parameters:

  entities - 实体对象集或数组

  properties - 属性名称列表，不能为null

  values - 属性值列表，和 properties 一一对应；可以是二维列表，即第二维的列表中包含属性的值时会返回 true。

• static List findAll(Object entities, String property, Object value)

  从集合中根据属性查找元素列表，代替findAll闭包以提升性能

  Parameters:

  entities - 实体对象集或数组

  property - 属性名称，如果为null，则表示直接用集合元素进行比较

  value - 属性值，可以是一个集合或数组

• static List findAll(Object entities, List<String> properties, List values)

  从集合中根据属性查找元素列表，代替findAll闭包以提升性能

  Parameters:

  entities - 实体对象集或数组

  properties - 属性名称列表，不能为null

  values - 属性值列表或数组

• static Map<Object, List> groupBy(Object entities, String property)

  根据集合中的元素属性对集合进行分组，代替 groupBy 闭包以提升性能

  Returns:

  以属性值为 key 的 Map <Object, List>

  Parameters:

  entities - 实体对象或Map集合或列表/数组

  property - 属性名称，不能为null

• static Map<String, List> groupBy(Object entities, List<String> properties, String splitter = ".")

  根据集合中的元素属性对集合进行分组，代替 groupBy 闭包以提升性能

  Returns:

  以多个属性值为 key 的 Map

  Parameters:

  entities - 实体对象或 Map 的集合（列表/数组）

  properties - 属性名称列表，不能为空

  splitter - 用来分隔多个属性值的，默认为"."

• static Map<Object, List> groupBy(Object entities, int index)

  根据二维集合中，第二维度内的元素下标，对集合进行分组

  Returns:

  以下标值为 key 的 Map <Object, List>

  Parameters:

  entities - 实体对象或 Map 的二维集合（列表/数组）

  index - 元素下标

• static List intersectSorted(List left, List right, Comparator comparator = null)

  求两个排序列表的交集（如果列表中有 null，应排首位）

  对于Map之类的数据，性能比原生方法提升数十倍；数字等类型的数据，性能也能提升25%左右。

  示例：
   CollectionUtils.intersectSorted( [[x:1], [x:2], [x:3]], [[x:2]], {a, b -> a.x <=> b.x} as Comparator )
   CollectionUtils.intersectSorted( [null,1,2,3,4,5,6,7,10,11,12], [null,2,3,7,9,11,19] ) == [null,2,3,7,11]

• static List paginate(List list, Map params)

  分页、排序，并返回当前页

  Parameters:

  params - 分页排序的参数Map，包括：sort（可以为 map 或 string）、order、offset、max

• static Map<String, List> removeBothSorted(List leftList, List rightList, Comparator comparator = null)

  分别删除两个已排序列表中的相同数据，并返回两个新的列表

  仅针对已排序的列表，效果几乎等同于 “[left: leftList - rightList, right: rightList - leftList]”，但性能提升600倍； 即便与 removeAll 方式相比，性能也提升150多倍。

  Returns:

  形如 [left: xxx, right: xxx] 的 Map 对象。

  Parameters:

  leftList - 已排序列表

  rightList - 已排序列表

• static List removeSorted(List sourceList, List removeList, Comparator comparator = null)

  删除两个已排序列表中的相同数据，并返回新的列表

  仅针对已排序的列表，效果几乎等同于 “sourceList - removeList”，但性能提升600倍。

  不同点：[1,1,2] - [1] = [2]，而本方法返回 [1, 2]，除非提前除重。

  Returns:

  新的列表

  Parameters:

  sourceList - 数据源列表，已排序

  removeList - 要删除的数据，已排序

  comparator - 用于求交集（算法中的一部分）的比较器，对于 Map 之类的结构可提升数十倍性能

• static Collection sort(Collection list, Map sorts)

  排序（含中文处理）

  Parameters:

  sorts - 形如 ['a.b.c.d': 'asc', 'x': 'desc', 'y.z': [order: 'desc', converter: 值转换闭包]] 的排序选项

• static Collection sort(Collection list, String order = "asc", Object element = null, Closure elementSwapper = null, Object element2 = null)

  排序（含中文处理）

  和原始的使用闭包的 Collection.sort 比较。

  1. 数字、日期、不含中文的字符串属性：性能提升8~10倍左右
  2. 中文字符串属性：性能为直接sort的一半左右

  Parameters:

  list - 要排序的集合

  order - asc/desc，排序顺序

  element - 排序属性名，如 name；可以为 “a.b”，表明根据属性 a 的子属性 b 进行排序，支持 4 级；或者获得排序信息的闭包。

  elementSwapper - 排序时，对排序数据进行二次处理的闭包，包含三个参数：用于排序的属性值列表、当前属性值、当前元素。 例如闭包 sequenceSwapper，可以将值 “1.1” 转成 “00001.00001.00000...” 再排序

  element2 - 当使用属性 element 排序时，如果两个元素的属性值一样，可以用这个补充属性做二次比较； 如果是字符串则同参数 element 一样可以支持4级，也可以是获得排序信息的闭包。

• static Number sum(Object entities, Object property = null, Integer scale = null)

  计算合计

  避免使用大量闭包、并且能对其他数字结果进行舍入和非空处理，相对使用闭包的Collection.sum，性能提升2~3倍甚至10倍以上。

  示例：assert 1 == CollectionUtils.sum( [[x:1, y:2]], 'x' )
   assert 3 == CollectionUtils.sum( [[x:1, y:2]], ['x','y'] )
   assert 3 == CollectionUtils.sum( [x:1, y:2] )
   assert 6 == CollectionUtils.sum( [1,2,3] )
   assert 15== CollectionUtils.sum( [[2011:5, 2012:10, 2013:15]], [2011, 2012] )
  

  Returns:

  合计值

  Parameters:

  entities - 实体对象集或数组

  property - 数字属性名称或者名称列表，默认为null，即将实体对象直接相加、或者实体对象是Map时将其所有value相加

  scale - 小数精度（四舍五入），默认为null，即不额外处理精度

• static List toList(Object o)

  将数组、集合等转换成列表对象

  本方法通常适用于读列表的情况：
  如果 o 是数组，将返回固定大小（不能增删元素）的列表，对列表的修改将直接应用到原来的数组上。
  如果 o 是列表，将直接返回原来的列表对象；
  如果 o 是其他类型的集合，比如 Set，会创建一个新的列表对象，并将集合里的元素添加到列表中；
  如果 o 是其他对象，会创建一个仅包含 o 的 ArrayList 并返回； 如果 o 是 null，则返回 null。

• static List unique(Collection source, Comparator comparator = null)

  快速除重，并返回一个新的列表

  使用 TreeSet 对列表进行排序，性能比 Groovy 的默认排序算法快400倍

• static List unique(Collection source, String property)

  根据列表元素的属性快速除重，并返回一个新的列表

• static List uniqueSorted(Collection source)

  对已排序的列表快速除重，并返回一个新的列表

  相对于上面的 unique 的方法，性能仍然还能提升约2~15倍。