Array数组集合

概述

数组集合相关函数

of

将多个元素转化为数组

Array.of(...item);

参数	类型	描述
item	Object	对象

返回值

类型 Array<Object> 返回数组

示例

Array.of(); //[]
Array.of('x', 2, 3, 4); //["x",2,3,4]
Array.of('x', null, 3, 4); //["x",null,3,4]

toList

将元素转化为数组

Array.toList(item);

参数	类型	描述
item	Object	对象，如果item为数组则clone一份返回

返回值

类型 Array<Object> 返回数组

示例

Array.toList(); //null
Array.toList('x', 2, 3, 4); //["x",2,3,4]
Array.toList(['x', 2, 3, 4]); //["x",2,3,4]
Array.toList('x', null, 3, 4); //["x",null,3,4]
Array.toList('x'); //["x"]
Array.toList(null); //[null]

join

按照 separator 将 array 数组的内容拼接在一起

Array.join(array, separator);

参数	类型	描述
array	Array	需要拼接的数组
separator	String	分隔符

返回值

类型 String 返回拼接的字符串

示例

Array.join([1, 2, 3, 4], '-'); //"1-2-3-4"
Array.join([1, 2, 3, 4], null); //"1234"
Array.join([1, null, 3, 4], null); //"134"
Array.join([null, null, null, null], null); //""
Array.join(null, '-'); //null
Array.join(null, null); //null

length

list 的元素个数

Array.length(list);

参数	类型	描述
list	Array	需要返回长度的数组

返回值

类型 Integer 返回数组的长度，如果数组为 null 返回 0

示例

Array.length([1, 2, 3, 4]); //4
Array.length([1, null, 3, 4]); //4
Array.length(null); //0

get

获取集合中的一个元素

如果是 List 集合则 key 就是 0~(len - 1) 的索引位置整数，返回的是该位置的值， 超过范围内的访问将抛出异常；如果是 Map 集合则 key 就是键值对的 key，返回的是对应的 value；

Array.get(list, key);

参数	类型	描述
list	Array 或者 Map	需要获取元素的集合
key	Integer 或者 String	元素的索引或者 键值

返回值

类型 Object 返回集合中的元素，如果元素不存在则返回 null

示例

Array.get([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], 1); //{name=李四}
Array.get([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], -1); //null
Array.get([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], 3); //null
Array.get([{ 'name': '张三' }, null, { 'name': '王五' }], 2); //{name=王五}
Array.get({ 'name': '张三' }, 'name'); //张三
Array.get({ 'name': '张三' }, 'age'); //null
Array.get(null, 3); //null

set

设置集合中的元素值。如果是 List 集合则替换 list 集合中项的 key为 value，如果是 Map 集合则 key 就是键值对的 key

Array.set(list, key, value);

参数	类型	描述
list	Array 或者 Map	需要设置元素的集合
key	String| Integer	属性值或索引
value	Object	需要设置的值

返回值

类型 Array|Map 返回修改后的集合

示例

Array.set({ 'name': '张三' }, 'name', '张三三'); //{"name":"张三三"}
Array.set([{ 'name': '张三', "age": 18 }, { 'name': '张三', "age": 24 }], 'age', 20); //[{ 'name': '张三', "age": 20 }, { 'name': '张三', "age": 20 }]
Array.set([{ 'name': '张三', "age": 18 }, { 'name': '张三', "age": 24 }], 1, 20); //[{ 'name': '张三', "age": 20 }, 20]

add

向集合 list 的尾部中添加元素 item

Array.add(list, item);

参数	类型	描述
list	Array	需要添加元素的集合
item	Object	要添加的元素

返回值

类型 Array 返回添加了元素后的集合

示例

Array.add([1, 2, 3, 4, 5, 6], { 'name': '李四' }); //[1,2,3,4,5,6,{"name":"李四"}]
Array.add([1, 2, 3, 4, 5, 6], 12); //[1,2,3,4,5,6,12]
Array.add(null, { 'name': '李四' }); //null

remove

将集合中的元素移除,如果集合是 Map 类型则 item 是 key

Array.remove(list, item);

参数	类型	描述
list	Array 或 Map	需要移除元素的集合
item	Object 或 String	要移除的元素、元素的 key

返回值

类型 Array或者Map 返回移除了元素后的集合

示例

Array.remove([1, 2, 3, 4, 5, 6], { 'name': '李四' }); //[1,2,3,4,5,6]
Array.remove([1, 2, 3, 4, 5, 6], 5); //[1,2,3,4,6]
Array.remove({ 'name': '李四', 'age': 30 }, 'name'); //{"age":30}
Array.remove({ 'name': '李四', 'age': 30 }, 'sex'); //{"name":"李四","age":30}
Array.remove(null, { 'name': '李四' }); //null
Array.remove([null,1,2,3,null], null); //[1,2,3,null]

注意事项

如果list为Array类型，remove内部元素时仅会删除第一个匹配的元素

removeAll

将集合中的元素移除,如果集合是 Map 类型则 item 是 key

Array.removeAll(list, item);

参数	类型	描述
list	Array 或 Map	需要移除元素的集合
item	Object 或 String或Array	要移除的元素、元素的 key、元素数组

返回值

类型 Array或者Map 返回移除了元素后的集合

示例

Array.removeAll([1, 2, 3, 4, 5, 6], { 'name': '李四' }); //[1,2,3,4,5,6]
Array.removeAll([1, 2, 3, 4, 5, 6], [1,5]); //[2,3,4,6]
Array.removeAll({ 'name': '李四', 'age': 30 }, 'name'); //{"age":30}
Array.removeAll({ 'name': '李四', 'age': 30 }, 'sex'); //{"name":"李四","age":30}
Array.removeAll(null, { 'name': '李四' }); //null
Array.removeAll([null,1,2,3,null], null); //[1,2,3]
Array.removeAll([null,1,2,3,null], [null,1]); //[2,3]

注意事项

如果list为Array类型，remove内部元素时仅会删除第一个匹配的元素

isEmpty

判断 list 是否是空集合；如果 list 为null或者长度为 0 返回 true，否则返回 false

Array.isEmpty(list);

参数	类型	描述
list	Array 或 Map	需要判断长度的集合

返回值

类型 Boolean 集合是否为空

示例

Array.isEmpty([1, 2, 3, 4, 5, 6]); //false
Array.isEmpty(0); //false
Array.isEmpty(1); //false
Array.isEmpty(0.0); //false
Array.isEmpty(1.0); //false
Array.isEmpty(null); //true
Array.isEmpty({ 'name': '李四', 'age': 30 }); //false
Array.isEmpty({}); //true
Array.isEmpty(''); //true

isNotEmpty

判断 list 是否不是空集合；如果 list 为null或者长度为 0 返回 false，否则返回 true

Array.isNotEmpty(list);

参数	类型	描述
list	Array 或 Map	需要判断长度的集合

返回值

类型 Boolean 集合是否不为空

示例

Array.isNotEmpty([1, 2, 3, 4, 5, 6]); //true
Array.isNotEmpty(0); //true
Array.isNotEmpty(1); //true
Array.isNotEmpty(0.0); //true
Array.isNotEmpty(1.0); //true
Array.isNotEmpty(null); //false
Array.isNotEmpty({ 'name': '李四', 'age': 30 }); //true
Array.isNotEmpty({}); //false
Array.isNotEmpty(''); //false

contains

判断 list 中是否包含 item

Array.contains(list, item);

参数	类型	描述
list	Array 或 Map	集合
item	Object	元素

返回值

类型 Boolean 集合 Array 或 Map 是否包含 item

示例

Array.contains([1, 2, 3, 4, 5, 6], 1); //true
Array.contains([2, 3, 4, 5, 6], 1); //false
Array.contains(['1', 2, 3, 4, 5, 6], 1); //false
Array.contains([{ 'name': '张三' }, { 'name': '李四' }], { 'name': '张三' }); //true
Array.contains(null, '1'); //false

containsAny

判断 list1 中是否包含 list2 中的任意元素

当 list1 为 null 时，始终返回false，当 list2 为空时始终返回true

Array.containsAny(list1, list2);

参数	类型	描述
list1	Array	集合 1
list2	Array	集合 2

返回值

类型 Boolean list1 是否包含 list2 中的任意元素

示例

Array.containsAny([1, 2, 3, 4, 5, 6], [1]); //true
Array.containsAny([1, 2, 3, 4, 5, 6], [8]); //false
Array.containsAny([1, 2, 3, 4, 5, 6], ['1']); //false
Array.containsAny([1, 2, 3, 4, 5, 6], null); //true
Array.containsAny(null, ['1']); //false
Array.containsAny(null, null); //false

containsAll

判断 list1 中是否包含 list2 中的所有元素

当 list1 或者 list2 为空时，始终返回false

Array.containsAll(list1, list2);

参数	类型	描述
list1	Array	集合 1
list2	Array	集合 2

返回值

类型 Boolean list1 是否包含 list2 中的所有元素

示例

Array.containsAll([1, 2, 3], [2, 3]); //true
Array.containsAll([1, 2, 3], [2, 3, 4]); //false
Array.containsAll([1, 2, 3], ['1', 2]); //false
Array.containsAll([1, 2, 3], [1, 2, 3, 4]); //false
Array.containsAll(null, ['1']); //false
Array.containsAll(null, null); //false

map

返回 list 中 key 属性的列表

Array.map(list, key);

参数	类型	描述
list	Array	集合 1
key	String	属性的 key

返回值

类型 Array list 中每个元素 key 属性的列表

示例

Array.map([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], 'name'); //["张三","李四","王五"]
Array.map([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], 'age'); //[null,null,null]
Array.map([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], null); //[]
Array.map([null, null, { 'name': '张三' }], 'name'); //[null,null,"张三"]
Array.map(null, 'name'); //[]

props

返回 list 中 元素的props列表组成的新对象列表

Array.props(list, props);

参数	类型	描述
list	Array	集合 1
props	Array<String>	属性的 key列表，如果props为null时会抛出异常

返回值

类型 Array list 中每个元素 props列表属性的构建的新列表

示例

Array.props([{ 'name': '张三', 'age': 1 }, { 'name': '李四', 'age': 2 }, { 'name': '王五', 'age': 3 }], 'name'); //[{'name':'张三'},{'name':'李四'},{'name':'王五'}]
Array.props([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], 'age'); //[{'age':null},{'age':null},{'age':null}]
Array.props([{ 'name': '张三' }, { 'name': '李四' }, { 'name': '王五' }], null); //异常情况
Array.props([null, null, { 'name': '张三' }], 'name'); //[{'name':'张三'}]
Array.props(null, 'name'); //[]

transform

返回 list 中 元素的按照mapping映射组成的新对象列表

Array.transform(list, mapping);

参数	类型	描述
list	Array	集合 1
mapping	Map<String,String>	属性的映射对象

返回值

返回 list 中 元素的mapping映射组成的新对象列表

示例

Array.transform([{ 'name': '张三', 'age': 1 }, { 'name': '李四', 'age': 2 }, { 'name': '王五', 'age': 3 }], { 'name': 'userName', 'age': 'userAge' }); //[{'userName':'张三','userAge':1},{'userName':'李四','userAge':2},{'userName':'王五','userAge':3}]
Array.transform([{ 'name': '张三', 'age': 1 }, { 'name': '李四', 'age': 2 }, { 'name': '王五', 'age': 3 }], { 'name': 'userName', 'sex': 'userSex' }); //[{'userName':'张三','userSex':null},{'userName':'李四','userSex':null},{'userName':'王五','userSex':null}]
Array.transform([{ 'name': '张三', 'age': 1 }, { 'name': '李四', 'age': 2 }, null], { 'name': 'userName', 'age': 'userAge' }); //[{'userName':'张三','userAge':1},{'userName':'李四','userAge':2}]
Array.transform([{ 'name': '张三', 'age': 1 }, { 'name': '李四', 'age': 2 }], null); //[]

concat

返回 list1 和 list2 拼接在一起

Array.concat(list1, list2);

参数	类型	描述
list1	Array	集合 1
list2	Array	集合 2

返回值

类型 Array list1 和 list2 拼接后的集合

示例

Array.concat([1, 2, 3], [2, 3]); //[1,2,3,2,3]
Array.concat([1, 2, 3], [2, 3, 4]); //[1,2,3,2,3,4]
Array.concat([1, 2, 3], ['1', 2]); //[1,2,3,"1",2]
Array.concat([1, 2, 3], [1, 2, 3, 4]); //[1,2,3,1,2,3,4]
Array.concat([1, 2, 3], null); //[1,2,3]
Array.concat(null, ['1']); //["1"]
Array.concat(null, null); //[]

sort

将 list 按照 key 属性排序

Array.sort(list, key);

参数	类型	描述
list	Array	集合
key	String	排序的属性

返回值

类型 Array 排序后的集合

示例

Array.sort([
    { 'name': 'a', 'age': 20 },
    { 'name': 'b', 'age': 18 },
    { 'name': 'c', 'age': 32 },
    { 'name': 'c', 'age': 24 }
], 'age'); //[{"name":"a","age":20},{"name":"b","age":18},{"name":"c","age":32},{"name":"c","age":24}]
Array.sort([{ 'male': true, 'age': 20 }, { 'male': false, 'age': 18 }, { 'male': true, 'age': 32 }], 'male'); //[{"male":true,"age":20},{"male":false,"age":18},{"male":true,"age":32}]
Array.sort([{ 'male': true, 'age': 20 }, { 'male': false, 'age': 18 }], null); //[{"male":true,"age":20},{"male":false,"age":18}]
Array.sort(null, 'age'); //null
Array.sort([5, 4, 9, 20, 32, 1, 244]); //[1,4,5,9,20,32,244]
Array.sort(null, null); //null

distinct

将 list 中的元素去除重复项返回

Array.distinct(list);

参数	类型	描述
list	Array	集合

返回值

类型 Array 去除重复后的集合

示例

Array.distinct([{ 'name': 'a', 'age': 20 }, { 'name': 'a', 'age': 20 }, { 'name': 'c', 'age': 32 }]); //[{"name":"a","age":20},{"name":"c","age":32}]
Array.distinct([1, 2, 2, 3, 4, 5, 67, 9]); //[1,2,3,4,5,67,9]
Array.distinct([1, 2, null, 3, 4, 5, null, 9]); //[1,2,null,3,4,5,9]
Array.distinct(null); //null

reverse

将 list 反转后返回

Array.reverse(list);

参数	类型	描述
list	Array	集合

返回值

类型 Array 反转后的集合

示例

Array.reverse([{ 'name': 'a', 'age': 20 }, { 'name': 'c', 'age': 32 }]); //[{"name":"c","age":32},{"name":"a","age":20}]
Array.reverse([1, 2, 3, 4, 5, 6, 7, 9]); //[9,7,6,5,4,3,2,1]
Array.reverse([1, 2, null, 3, 4, 5, null, 9]); //[9,null,5,4,3,null,2,1]
Array.reverse(null); //null

repeat

生成一个每一项是 element 且长度为 count 的数组

Array.repeat(count, element);

参数	类型	描述
count	Integer	重复次数
element	Object	重复的元素

返回值

类型 Array 生成的数组

示例

Array.repeat(4, { 'name': 'a' }); //[{"name":"a"},{"name":"a"},{"name":"a"},{"name":"a"}]
Array.repeat(4, 1); //[1,1,1,1]
Array.repeat(3, 'a'); //["a","a","a"]
Array.repeat(3, null); //[null,null,null]

sublist

返回 list 的 fromIndex 到 toIndex 的部分

Array.sublist(list, fromIndex, toIndex);

参数	类型	描述
list	Array	集合
fromIndex	Integer	起始索引，如果为 null 则从 0 开始
endIndex	Integer	结束索引,如果为 null 则为 list 的最后一个元素的位置

返回值

类型 Array 生成的数组,如果 list 为空则返回 null

示例

Array.sublist([1, 2, 3, 4], 0, 1); //[1,2]
Array.sublist([1, 2, 3, 4], 0, 100); //[1,2,3,4]
Array.sublist([1, 2, 3, 4], 1, 1); //[2]
Array.sublist([1, 2, 3, 4], null, null); //[]
Array.sublist([1, 2, 3, 4], null, 2); //[1,2,3]
Array.sublist([1, 2, 3, 4], 1, null); //[2,3,4]
Array.sublist(null, 0, 1); //null

filter

从列表 list 过滤列表项属性 key 的值等于 value 的项

Array.filter(list, key, value);

参数	类型	描述
list	Array	集合
key	String	比较的属性 key
value	Object	比较的属性值

返回值

类型 Array 过滤后满足条件的数组

示例

Array.filter([{ a: 1 }, { a: 2 }, { a: 2 }], "a", 2); //[{"a":2},{"a":2}]
Array.filter(null, "a", 2); //[]
Array.filter([{ a: 1 }, { a: 2 }, { a: 2 }], null, 2); //[]

shift

移除 list 头部的元素并返回被移除的元素

Array.shift(list);

参数	类型	描述
list	Array	集合

返回值

类型 Object 头部的元素

示例

Array.shift([1, 2, 3]); //1
Array.shift([]); //null
Array.shift(null); //null

pop

移除 list 尾部的元素并返回被移除的元素

Array.pop(list);

参数	类型	描述
list	Array	集合

返回值

类型 Object 尾部的元素

示例

Array.pop([1, 2, 3]); //3
Array.pop([]); //null
Array.pop(null); //null

sum

对元素为数字类型的 list 进行求和计算

Array.sum(list);

参数	类型	描述
list	Array	集合

返回值

类型 Double 求和的结果

示例

Array.sum([1, 2, 3]); //6.0
Array.sum([]); //0.0
Array.sum([null, null, null]); //0.0
Array.sum([1, null, 2]); //3.0
Array.sum(null); //0.0
Array.sum(["1", "2", "3"]); //6.0 如果数组元素类型是字符串，则系统会转化为小数;如果转化失败返回0
Array.sum(["1", "2", "s"]); //3.0 如果数组元素类型是字符串，如果转化失败则当做0

avg

对元素为数字类型的 list 进行求平均值计算

Array.avg(list);

参数	类型	描述
list	Array	集合

返回值

类型 Double 求平均值的结果

示例

Array.avg([1, 2, 3]); //2.0
Array.avg([]); //0.0
Array.avg([null, null, null]); //0.0
Array.avg([1, null, 2]); //1.0
Array.avg(null); //0.0
Array.avg(["1", "2", "3"]); //2.0 如果数组元素类型是字符串，则系统会转化为小数;如果转化失败返回0
Array.avg(["1", "2", "s"]); //1.0 如果数组元素类型是字符串，如果转化失败则当做0

max

对元素为数字类型的 list 进行求最大值计算

Array.max(list);

参数	类型	描述
list	Array	集合

返回值

类型 Double list 中的最大值

示例

Array.max([1, 2, 3]); //3.0
Array.max([]); //null
Array.max([null, null, null]); //null
Array.max([1, null, 2]); //2.0
Array.max(null); //null
Array.max(["1", "2", "3"]); //3.0 如果数组元素类型是字符串，则系统会转化为小数;如果转化失败
Array.max(["1", "2", "s"]); //2.0 如果数组元素类型是字符串，如果转化失败则当做0

min

对元素为数字类型的 list 进行求最小值计算

Array.min(list);

参数	类型	描述
list	Array	集合

返回值

类型 Double list 中的最小值

示例

Array.min([1, 2, 3]); //1.0
Array.min([]); //null
Array.min([null, null, null]); //null
Array.min([1, null, 2]); //1.0
Array.min(null); //null
Array.min(["1", "2", "3"]); //1.0 如果数组元素类型是字符串，则系统会转化为小数;如果转化失败返回0
Array.min(["1", "2", "s"]); //1.0 如果数组元素类型是字符串，如果转化失败则忽略

first

返回 list 中的第一个元素

Array.first(list);

参数	类型	描述
list	Array	集合

返回值

类型 Object list 中第一个元素

示例

Array.first([1, 2, 3]); //1
Array.first([]); //null
Array.first(null); //null

last

返回 list 中的最后一个元素

Array.last(list);

参数	类型	描述
list	Array	集合

返回值

类型 Object list 中最后一个元素

示例

Array.last([1, 2, 3]); //3
Array.last([]); //null
Array.last(null); //null

stream

创建数组流，用于链式调用数组操作

Array.stream(array)

参数	类型	描述
array	Array	数组或集合

返回值

类型 ArrayStream 返回一个数组流对象，可以链式调用数组操作方法。

示例

Array.stream([1, 2, 3, 4, 5])
  .filter('value', '>', 2)
  .sort()
  .get()

ArrayStream 方法

ArrayStream 对象提供以下链式方法：

get

返回当前数组

stream.get()

返回值

类型 Array 当前数组

length

返回数组长度

stream.length()

返回值

类型 Number 数组长度

add

向数组添加元素

stream.add(item)

参数	类型	描述
item	Object	要添加的元素

返回值 ArrayStream 自身，用于链式调用。

remove

从数组移除元素

stream.remove(item)

参数	类型	描述
item	Object	要移除的元素

返回值 ArrayStream 自身，用于链式调用。

removeAll

从数组移除多个元素

stream.removeAll(items)

参数	类型	描述
items	Array	要移除的元素数组

返回值 ArrayStream 自身，用于链式调用。

sort

按指定属性排序数组

stream.sort(key)

参数	类型	描述
key	String	排序的属性

返回值 ArrayStream 自身，用于链式调用。

map

提取数组中每个元素的指定属性

stream.map(key)

参数	类型	描述
key	String	要提取的属性

返回值 ArrayStream 自身，用于链式调用。

props

提取数组中每个元素的多个属性

stream.props(props)
stream.props(propArray)

参数	类型	描述
props	Array<String>	属性列表
propArray	String...	属性可变参数

返回值 ArrayStream 自身，用于链式调用。

transform

转换数组中每个元素的属性名

stream.transform(mapping)

参数	类型	描述
mapping	Map<String,String>	属性映射关系

返回值 ArrayStream 自身，用于链式调用。

repeat

重复数组元素

stream.repeat(count, item)

参数	类型	描述
count	Integer	重复次数
item	Object	重复的元素

返回值 ArrayStream 自身，用于链式调用。

reverse

反转数组

stream.reverse()

返回值 ArrayStream 自身，用于链式调用。

distinct

数组去重

stream.distinct()

返回值 ArrayStream 自身，用于链式调用。

sublist

获取子数组

stream.sublist(from, end)

参数	类型	描述
from	Integer	起始索引
end	Integer	结束索引

返回值 ArrayStream 自身，用于链式调用。

shift

移除数组第一个元素

stream.shift()

返回值 ArrayStream 自身，用于链式调用。

pop

移除数组最后一个元素

stream.pop()

返回值 ArrayStream 自身，用于链式调用。

concat

连接另一个数组

stream.concat(list)

参数	类型	描述
list	Array	要连接的数组

返回值 ArrayStream 自身，用于链式调用。

filter

过滤数组元素

stream.filter(key, value)

参数	类型	描述
key	String	比较的属性 key
value	Object	比较的属性值

返回值 ArrayStream 自身，用于链式调用。

set

设置数组元素值

stream.set(key, value)

参数	类型	描述
key	Object	索引或属性名
value	Object	要设置的值

返回值 ArrayStream 自身，用于链式调用。

sum

计算数组元素总和

stream.sum()

返回值

类型 Number 数组元素总和

avg

计算数组元素平均值

stream.avg()

返回值

类型 Number 数组元素平均值

max

获取数组元素最大值

stream.max()

返回值

类型 Number 数组元素最大值

min

获取数组元素最小值

stream.min()

返回值

类型 Number 数组元素最小值

first

获取数组第一个元素

stream.first()

返回值

类型 Object 数组第一个元素

last

获取数组最后一个元素

stream.last()

返回值

类型 Object 数组最后一个元素