# Array数组集合

## 概述

数组集合相关函数

## of

将多个元素转化为数组

```javascript
Array.of(...item);
```

| 参数   | 类型       | 描述 |
|------|----------|----|
| item | `Object` | 对象 |

**返回值**

类型 `Array<Object>`
返回数组

**示例**

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

## toList

将元素转化为数组

```javascript
Array.toList(item);
```

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

**返回值**

类型 `Array<Object>` 返回数组

**示例**

```javascript
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 数组的内容拼接在一起

```javascript
Array.join(array, separator);
```

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

**返回值**

类型 `String`
返回拼接的字符串

**示例**

```javascript
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 的元素个数

```javascript
Array.length(list);
```

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

**返回值**

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

**示例**

```javascript
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；

```javascript
Array.get(list, key);
```

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

**返回值**

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

**示例**

```javascript
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

```javascript
Array.set(list, key, value);
```

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

**返回值**

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

**示例**

```javascript
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

```javascript
Array.add(list, item);
```

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

**返回值**

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

**示例**

```javascript
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

```javascript
Array.remove(list, item);
```

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

**返回值**

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

**示例**

```javascript
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]
```

:::warning 注意事项
如果**list**为`Array`类型，remove内部元素时仅会删除`第一个匹配`的元素
:::

## removeAll

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

```javascript
Array.removeAll(list, item);
```

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

**返回值**

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

**示例**

```javascript
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]
```

:::warning 注意事项
如果**list**为`Array`类型，remove内部元素时仅会删除`第一个匹配`的元素
:::

## isEmpty

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

```javascript
Array.isEmpty(list);
```

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

**返回值**

类型 `Boolean` 集合是否为空

**示例**

```javascript
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

```javascript
Array.isNotEmpty(list);
```

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

**返回值**

类型 `Boolean` 集合是否不为空

**示例**

```javascript
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

```javascript
Array.contains(list, item);
```

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

**返回值**

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

**示例**

```javascript
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`

```javascript
Array.containsAny(list1, list2);
```

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

**返回值**

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

**示例**

```javascript
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`

```javascript
Array.containsAll(list1, list2);
```

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

**返回值**

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

**示例**

```javascript
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 属性的列表

```javascript
Array.map(list, key);
```

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

**返回值**

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

**示例**

```javascript
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列表组成的新对象列表

```javascript
Array.props(list, props);
```

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

**返回值**

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

**示例**

```javascript
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映射组成的新对象列表

```javascript
Array.transform(list, mapping);
```

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

**返回值**

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

**示例**

```javascript
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 拼接在一起

```javascript
Array.concat(list1, list2);
```

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

**返回值**

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

**示例**

```javascript
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 属性排序

```javascript
Array.sort(list, key);
```

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

**返回值**

类型 `Array` 排序后的集合

**示例**

```javascript
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 中的元素去除重复项返回

```javascript
Array.distinct(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Array` 去除重复后的集合

**示例**

```javascript
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 反转后返回

```javascript
Array.reverse(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Array` 反转后的集合

**示例**

```javascript
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 的数组

```javascript
Array.repeat(count, element);
```

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

**返回值**

类型 `Array` 生成的数组

**示例**

```javascript
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 的部分

```javascript
Array.sublist(list, fromIndex, toIndex);
```

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

**返回值**

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

**示例**

```javascript
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 的项

```javascript
Array.filter(list, key, value);
```

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

**返回值**

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

**示例**

```javascript
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 头部的元素并返回被移除的元素

```javascript
Array.shift(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Object` 头部的元素

**示例**

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

## pop

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

```javascript
Array.pop(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Object` 尾部的元素

**示例**

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

## sum

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

```javascript
Array.sum(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Double` 求和的结果

**示例**

```javascript
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 进行求平均值计算

```javascript
Array.avg(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Double` 求平均值的结果

**示例**

```javascript
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 进行求最大值计算

```javascript
Array.max(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Double` list 中的最大值

**示例**

```javascript
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 进行求最小值计算

```javascript
Array.min(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Double` list 中的最小值

**示例**

```javascript
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 中的第一个元素

```javascript
Array.first(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Object` list 中第一个元素

**示例**

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

## last

返回 list 中的最后一个元素

```javascript
Array.last(list);
```

| 参数   | 类型      | 描述 |
|------|---------|----|
| list | `Array` | 集合 |

**返回值**

类型 `Object` list 中最后一个元素

**示例**

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

## stream

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

```javascript
Array.stream(array)
```

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

**返回值**

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

**示例**

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

### ArrayStream 方法

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

#### get

返回当前数组

```javascript
stream.get()
```

**返回值**

类型 `Array` 当前数组

#### length

返回数组长度

```javascript
stream.length()
```

**返回值**

类型 `Number` 数组长度

#### add

向数组添加元素

```javascript
stream.add(item)
```

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

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

#### remove

从数组移除元素

```javascript
stream.remove(item)
```

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

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

#### removeAll

从数组移除多个元素

```javascript
stream.removeAll(items)
```

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

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

#### sort

按指定属性排序数组

```javascript
stream.sort(key)
```

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

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

#### map

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

```javascript
stream.map(key)
```

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

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

#### props

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

```javascript
stream.props(props)
stream.props(propArray)
```

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

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

#### transform

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

```javascript
stream.transform(mapping)
```

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

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

#### repeat

重复数组元素

```javascript
stream.repeat(count, item)
```

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

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

#### reverse

反转数组

```javascript
stream.reverse()
```

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

#### distinct

数组去重

```javascript
stream.distinct()
```

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

#### sublist

获取子数组

```javascript
stream.sublist(from, end)
```

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

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

#### shift

移除数组第一个元素

```javascript
stream.shift()
```

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

#### pop

移除数组最后一个元素

```javascript
stream.pop()
```

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

#### concat

连接另一个数组

```javascript
stream.concat(list)
```

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

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

#### filter

过滤数组元素

```javascript
stream.filter(key, value)
```

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

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

#### set

设置数组元素值

```javascript
stream.set(key, value)
```

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

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

#### sum

计算数组元素总和

```javascript
stream.sum()
```

**返回值**

类型 `Number` 数组元素总和

#### avg

计算数组元素平均值

```javascript
stream.avg()
```

**返回值**

类型 `Number` 数组元素平均值

#### max

获取数组元素最大值

```javascript
stream.max()
```

**返回值**

类型 `Number` 数组元素最大值

#### min

获取数组元素最小值

```javascript
stream.min()
```

**返回值**

类型 `Number` 数组元素最小值

#### first

获取数组第一个元素

```javascript
stream.first()
```

**返回值**

类型 `Object` 数组第一个元素

#### last

获取数组最后一个元素

```javascript
stream.last()
```

**返回值**

类型 `Object` 数组最后一个元素
