!1356 add containers class API interface reference description

Merge pull request !1356 from parrotli/linhaoran

zh-cn/application-dev/reference/apis/Readme-CN.md

@@ -73,4 +73,18 @@
     - [xml解析与生成](js-apis-xml.md)
     - [xml转换JavaScript](js-apis-convertxml.md)
     - [启动一个worker](js-apis-worker.md)
+    - [线性容器ArrayList](js-apis-arraylist.md)
+    - [线性容器Deque](js-apis-deque.md)
+    - [线性容器List](js-apis-list.md)
+    - [线性容器LinkedList](js-apis-linkedlist.md)
+    - [线性容器Queue](js-apis-queue.md)
+    - [线性容器Stack](js-apis-stack.md)
+    - [线性容器Vector](js-apis-vector.md)
+    - [非线性容器HashSet](js-apis-hashset.md)
+    - [非线性容器HashMap](js-apis-hashmap.md)
+    - [非线性容器PlainArray](js-apis-plainarray.md)
+    - [非线性容器TreeMap](js-apis-treemap.md)
+    - [非线性容器TreeSet](js-apis-treeset.md)
+    - [非线性容器LightWeightMap](js-apis-lightweightmap.md)
+    - [非线性容器LightWeightSet](js-apis-lightweightset.md)
 

zh-cn/application-dev/reference/apis/js-apis-arraylist.md

+# 线性容器ArrayList
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import ArrayList from '@ohos.arraylist'  
+```
+
+
+## 权限
+
+无
+
+
+## ArrayList
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | 获取ArrayList 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是ArrayList的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let arraylist = new ArrayList();
+  ```
+
+
+### add
+
+add(element: T): boolean
+
+在ArrayList尾部插入元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 插入成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add("a");
+  arraylist.add(1);
+  let b = [1,2,3];
+  arraylist.add(b);
+  let c = {name:"lala",age:"13"};
+  arraylist.add(false)
+  ```
+
+### insert
+
+insert(element: T, index: number): void
+
+在长度范围内任意插入指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被插入的元素 |
+  | index | number | 是 | 被插入的元素 |
+
+- 示例:
+  ```
+  let arraylist = new ArrayList()
+  arraylist.insert("A",0);
+  arraylist.insert(0,1);
+  arraylist.insert(true,2);
+
+  ```
+
+### has
+
+has(element: T): boolean
+
+判断此ArrayList中是否含有该指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList()
+  arraylist.has("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  arraylist.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  arraylist.has("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+
+  ```
+
+### getIndexOf
+
+getIndexOf(element: T): number
+
+查找指定元素第一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回第一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(2);
+  arraylist.add(1);
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.getIndexOf(2);
+
+  ```
+### getLastIndexOf
+
+getLastIndexOf(element: T): number
+
+查找指定元素最后一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回最后一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(2);
+  arraylist.add(1);
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.getLastIndexOf(2);
+
+  ```
+### removeByIndex
+
+removeByIndex(index: number): T
+
+根据下标删除元素并返回该删除元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 删除元素的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.removeByIndex(2);
+
+  ```
+
+### remove
+
+remove(element: T): boolean
+
+删除查找到的第一个指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 删除成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.remove(2);
+
+  ```
+### removeByRange
+removeByRange(fromIndex: number, toIndex: number): void
+
+从一段范围删除元素,包前不包后.
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | fromIndex | number | 是 | 起始下标 |
+  | toIndex | number | 是 | 终止下标 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.removeByRange(2,4);
+  arraylist.removeByRange(4,3);
+  arraylist.removeByRange(2,6);
+
+  ```
+### replaceAllElements
+replaceAllElements(callbackfn: (value: T, index?: number, arraylist?: ArrayList<T>) => T,
+thisArg?: Object): void
+
+用户操作ArrayList中的元素,用操作后的元素替换原元素并返回操作后的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | arraylist | ArrayList<T> | 否 | 当前调用replaceAllElements方法的实例对象。 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.replaceAllElements((value,index)=>{
+    return value = 2*value;
+  });
+  arraylist.replaceAllElements((value,index)=>{
+    return value = value - 2;
+  });
+
+  ```
+### forEach
+forEach(callbackfn: (value: T, index?: number, arraylist?: ArrayList<T>) => void,
+thisArg?: Object): void 
+
+通过回调函数来遍历ArrayList实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | arraylist | ArrayList<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.forEach((value,index)=>{
+    console.log(value,index)
+  });
+
+  ```
+### sort
+sort(comparator?: (firstValue: T, secondValue: T) => number): void
+ 
+对ArrayList中的元素进行一个排序操作
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | comparator | function | 否 | 回调函数。 |
+
+- comparator的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | firstValue | T | 是 | 前一项元素 |
+  | secondValue | T | 是 | 后一项元素 |
+ 
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.sort(a,b=>a-b);
+  arraylist.sort(a,b=>b-a);
+  arraylist.sort()
+
+  ```
+### subArrayList
+subArrayList(fromIndex: number, toIndex: number): ArrayList<T>
+
+根据下标截取ArrayList中的一段元素,并返回这一段ArrayList实例,包前不包后
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | fromIndex | number | 是 | 起始下标 |
+  | toIndex | number | 是 | 终止下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | ArrayList<T> | 返回ArrayList对象实例 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.subArrayList(2,4);
+  arraylist.subArrayList(4,3);
+  arraylist.subArrayList(2,6);
+ 
+  ```
+
+### clear
+clear(): void
+
+清除ArrayList中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.clear();
+ 
+  ```
+### clone
+clone(): ArrayList<T> 
+
+克隆一个与ArrayList一模一样的实例,并返回克隆后的实例,修改克隆后的实例并不会影响原实例
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | ArrayList<T> | 返回ArrayList对象实例 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.clone();
+ 
+  ```
+### getCapacity
+getCapacity(): number
+
+获取当前实例的容量大小
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回arraylist的容量大小 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.getCapacity();
+
+  ```
+### convertToArray
+convertToArray(): Array<T>
+
+把当前ArrayList实例转换成数组,并返回转换后的数组
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Array<T> | 返回数组类型 |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.convertToArray();
+
+  ```
+### isEmpty
+isEmpty(): boolean 
+
+判断该ArrayList是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.isEmpty();
+
+  ```
+### increaseCapacityTo
+increaseCapacityTo(newCapacity: number): void
+
+如果该新容量大于活等于length,把容量改变为一个传入的新容量
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | newCapacity | number | 是 | 新容量 |
+
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.increaseCapacityTo(2);
+  arraylist.increaseCapacityTo(8);
+
+  ```
+### trimToCurrentLength
+trimToCurrentLength(): void
+
+把容量限制为当前的length大小
+
+- 示例:
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  arraylist.trimToCurrentLength(2);
+
+  ```
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  const arraylist = new ArrayList();
+  arraylist.add(2);
+  arraylist.add(4);
+  arraylist.add(5);
+  arraylist.add(4);
+  for (let item of arraylist) { 
+    console.log(item); 
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-deque.md

+# 线性容器Deque
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import Deque from '@ohos.deque'  
+```
+
+
+## 权限
+
+无
+
+
+## Deque
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | 获取Deque 的元素个数 |
+
+
+### constructor
+
+constructor() 
+
+constructor是Deque的构造函数。
+
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let queue = new Queue();
+  ```
+
+
+### insertFront
+
+insertFront(element: T): void 
+
+在deque头部插入元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 示例:
+  ```
+  const deque = new Deque;
+  deque.insertFront("a");
+  deque.insertFront(1);
+  let b = [1,2,3];
+  deque.insertFront(b);
+  let c = {name:"lala",age:"13"};
+  deque.insertFront(false)
+  ```
+### insertEnd
+
+insertEnd(element: T): void 
+
+在deque尾部插入元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 示例:
+  ```
+  const deque = new Deque;
+  deque.insertEnd("a");
+  deque.insertEnd(1);
+  let b = [1,2,3];
+  deque.insertEnd(b);
+  let c = {name:"lala",age:"13"};
+  deque.insertEnd(false)
+  ```
+### has
+
+has(element: T): boolean
+
+判断此Deque中是否含有该指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  const deque = new Deque()
+  deque.has("Ahfbrgrbgnutfodgorrogorg");
+  deque.insertFront("Ahfbrgrbgnutfodgorrogorg");
+  deque.has("Ahfbrgrbgnutfodgorrogorg");
+
+  ```
+### popFirst
+
+popFirst(): T
+
+删除并返回双端队列的首元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const deque = new Deque();
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.insertEnd(5);
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.popFirst();
+
+  ```
+### popLast
+
+popLast(): T
+
+删除并返回双端队列的尾元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const deque = new Deque();
+  deque.insertFront(2);
+  deque.insertEnd(4);
+  deque.insertFront(5);
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.popLast();
+
+  ```
+
+### forEach
+forEach(callbackfn: (value: T, index?: number, deque?: Deque<T>) => void,
+thisArg?: Object): void 
+
+通过回调函数来遍历Deque实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | deque | Deque<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+- 示例:
+  ```
+  const deque = new Deque();
+  deque.insertFront(2);
+  deque.insertEnd(4);
+  deque.insertFront(5);
+  deque.insertEnd(4);
+  deque.forEach((value,index)=>{
+    console.log(value,index)
+  });
+
+  ```
+
+### getFirst
+
+getFirst(): T
+获取Deque实例中的头元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  const deque = new Deque();
+  deque.insertEnd(2);
+  deque.insertEnd(4);
+  deque.insertFront(5);
+  deque.insertFront(4);
+  deque.getFirst();
+  ```
+### getLast
+
+getLast(): T 
+获取Deque实例中的尾元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  const deque = new Deque();
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.insertFront(5);
+  deque.insertFront(4);
+  deque.getLast();
+  ```
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  const deque = new Deque();
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.insertFront(5);
+  deque.insertFront(4);
+  for (let item of deque) { 
+    console.log(item); 
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-hashmap.md

+# 非线性容器HashMap
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import hashmap from '@ohos.hashmap'  
+```
+
+
+## 权限
+
+无
+
+## HashMap
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | HashMap 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是HashMap的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let hashmap = new HashMap();
+  ```
+
+
+### isEmpty
+
+isEmpty(): boolean 
+
+判断该HashMap是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const hashmap = new HashMap();
+  hashmap.isEmpty();
+  ```
+
+
+### hasKey
+
+hasKey(key: K): boolean
+
+判断此HashMap中是否含有该指定key
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.hasKey("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.hasKey("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  ```
+
+
+### hasValue
+
+hasValue(value: V): boolean
+
+判断此HashMap中是否含有该指定value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | V | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.hasValue(123);
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.hasValue(123);
+  ```
+
+
+### get
+
+get(key: K): V
+
+获取指定key所对应的value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 查找的指定key |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | V | 返回key映射的value值 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  hashmap.get("sdfs");
+  ```
+
+
+### setAll
+
+setAll(map: HashMap<K, V>): void
+
+将一个HashMap中的所有元素组添加到另一个hashmap中
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | map | HashMap<K, V> | 是 | 被添加元素的hashmap |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  let newhashmap = new HashMap();
+  hashmap.setAll(newhashmap);
+  ```
+
+
+### set
+
+set(key: K, value: V): Object;
+
+向HashMap中添加一组数据
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 添加成员数据的键名。 |
+  | value | V | 是 | 添加成员数据的值。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Object | 返回添加后的hashmap |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  ```
+
+
+### remove
+
+remove(key: K): V;
+
+删除指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 依据key指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | V | 返回删除元素的值 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  hashmap.remove("sdfs");
+  ```
+
+
+### clear
+
+clear(): void
+
+清除HashMap中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  hashmap.clear();
+  ```
+
+
+### keys
+
+keys(): IterableIterator<K>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[K,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  let itor = hashmap.keys();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  }
+  ```
+
+
+### values
+
+values(): IterableIterator<V>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[K,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  let itor = hashmap.values();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  }
+  ```
+
+
+### replace
+
+replace(key: K, value: V): boolean;
+
+对HashMap中一组数据进行更新（替换）
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 依据key指定替换的元素。 |
+  | value | V | 是 | 添加成员数据的值。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否成功对已有数据进行替换 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("sdfs", 123);
+  hashmap.replace("sdfs", 357);
+  ```
+
+
+### forEach
+
+forEach(callbackfn: (value: V, key?: K, hashmap?: HashMap<K, V>) => void, thisArg?: Object): void 
+
+通过回调函数来遍历HashMap实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | V | 是 | 当前遍历到的元素键值对的值。 |
+  | key | K | 是 | 当前遍历到的元素键值对的键。 |
+  | hashmap | HashMap<K, V> | 否 | 当前调用forEach方法的实例对象。 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("sdfs", 123);
+  hashmap.set("dfsghsf", 357);
+  hashmap.forEach((value, key)=>{
+    console.log(value, key)
+  });
+  ```
+
+
+### entries
+
+entries(): IterableIterator<[K, V]>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[K, V],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  let itor = hashmap.entries();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp.key);
+    console.log(temp.value);
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<[K, V]>
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[K, V],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例：
+  ```
+  let hashmap = new HashMap();
+  hashmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashmap.set("sdfs", 356);
+  for (let item of hashmap) { 
+    console.log("key: " + item.key);
+    console.log("value: " + item.value);
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-hashset.md

+# 非线性容器HashSet
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import hashset from '@ohos.hashset'  
+```
+
+
+## 权限
+
+无
+
+## HashSet
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | HashSet 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是HashSet的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let hashset = new HashSet();
+  ```
+
+
+### isEmpty
+
+isEmpty(): boolean 
+
+判断该HashSet是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const hashset = new HashSet();
+  hashset.isEmpty();
+  ```
+
+
+### has
+
+has(value: T): boolean
+
+判断此HashSett中是否含有该指定key
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let hashset = new HashSet();
+  hashset.has("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.has("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  ```
+
+
+### add
+
+add(value: T): boolean;
+
+向HashSet中添加数据
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 添加成员数据。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 返回是否有成功增加元素 |
+
+- 示例:
+  ```
+  let hashset = new HashSet();
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  ```
+
+
+### remove
+
+remove(value: T): boolean;
+
+删除指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 返回是否成功删除指定元素 |
+
+- 示例:
+  ```
+  let hashset = new HashSet();
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.add("sdfs");
+  hashset.remove("sdfs");
+  ```
+
+
+### clear
+
+clear(): void
+
+清除HashSet中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  let hashset = new HashSet();
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.add("sdfs");
+  hashset.clear();
+  ```
+
+
+### values
+
+values(): IterableIterator<T>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let hashset = new HashSet();
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.add("sdfs");
+  let itor = hashset.values();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  } 
+  ```
+
+
+### forEach
+
+forEach(callbackfn: (value: T, key?: T, hashset?: HashSet<T>) => void, thisArg?: Object): void 
+
+通过回调函数来遍历实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素键值对的值。 |
+  | key | T | 否 | 当前遍历到的元素键值对的值（和value相同）。 |
+  | hashset | HashSet<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+
+- 示例:
+  ```
+  let hashset = new HashSet();
+  hashset.add("sdfs");
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.forEach((value, key)=>{
+    console.log(value, key)
+  });
+  ```
+
+
+### entries
+entries(): IterableIterator<[T, T]>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[T, T],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let hashset = new HashSet();
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.add("sdfs");
+  let itor = hashset.entries();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp.key);
+    console.log(temp.value);
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例：
+  ```
+  let hashset = new HashSet();
+  hashset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashset.add("sdfs");
+  for (let item of hashset) { 
+    console.log("value: " + item);
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-lightweightmap.md

+# 非线性容器LightWeightMap 
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import LightWeightMap from '@ohos.lightweightmap'  
+```
+
+
+## 权限
+
+无
+
+## LightWeightMap
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | LightWeightMap 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是LightWeightMap的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let lightweightmap = new LightWeightMap();
+  ```
+
+
+### isEmpty
+
+isEmpty(): boolean 
+
+判断该LightWeightMap是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const lightweightmap = new LightWeightMap();
+  lightweightmap.isEmpty();
+  ```
+
+
+### hasAll
+
+hasAll(map: LightWeightMap<K, V>): boolean;
+
+判断此LightWeightMap中是否含有该指定map中的所有元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | map | LightWeightMap<K, V> | 是 | 比较对象 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含所有元素 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  let map = new LightWeightMap();
+  map.set("sdfs", 356);
+  let result = lightweightmap.hasAll(map);
+  ```
+
+
+### hasKey
+
+hasKey(key: K): boolean
+
+判断此LightWeightMap中是否含有该指定key
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.hasKey("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.hasKey("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  ```
+
+
+### hasValue
+
+hasValue(value: V): boolean
+
+判断此LightWeightMap中是否含有该指定value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | V | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.hasValue(123);
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.hasValue(123);
+  ```
+
+
+### increaseCapacityTo
+
+increaseCapacityTo(minimumCapacity: number): void
+
+将当前LightWeightMap扩容至可以容纳指定数量元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | minimumCapacity | number | 是 | 需要容纳数量 |
+
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.increaseCapacityTo(10);
+  ```
+
+
+### get
+
+get(key: K): V
+
+获取指定key所对应的value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 查找的指定key |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | V | 返回key映射的value值 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.get("sdfs");
+  ```
+
+
+### getIndexOfKey
+
+getIndexOfKey(key: K): number
+
+查找指定元素第一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回第一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.getIndexOfKey("sdfs");
+  ```
+
+
+### getIndexOfValue
+
+getIndexOfValue(value: V): number
+
+查找指定元素第一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | V | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回第一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.getIndexOfValue(123);
+  ```
+
+
+### getKeyAt
+
+getKeyAt(index: number): K
+
+查找指定下标的元素键值对中key值，否则返回undefined
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 所查找的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | K | 返回该下标对应的元素键值对中key值 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.getKeyAt(1);
+  ```
+
+
+### setAll
+
+setAll(map: LightWeightMap<K, V>): void
+
+将一个LightWeightMap中的所有元素组添加到另一个lightweightmap中
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | map | LightWeightMap<K, V> | 是 | 被添加元素的lightweightmap |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  let map = new LightWeightMap();
+  lightweightmap.setAll(map);
+  ```
+
+
+### set
+set(key: K, value: V): Object;
+
+向LightWeightMap中添加一组数据
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 添加成员数据的键名。 |
+  | value | V | 是 | 添加成员数据的值。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Object | 返回添加后的hashmap |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  ```
+
+
+### remove
+
+remove(key: K): V;
+
+删除指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 依据key指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | V | 返回删除元素的值 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.remove("sdfs");
+  ```
+
+
+### removeAt
+
+removeAt(index: number): boolean;
+
+删除指定下标的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定想要删除元素下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 确认是否成功删除元素 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.removeAt(1);
+  ```
+
+
+### setValueAt
+
+setValueAt(index: number, newValue: V): boolean
+
+向LightWeightMap中具体位置替换键值对中的值
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定替换数据下标 |
+  | newValue | V | 是 | 替换键值对中的值 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否成功替换指定位置数据 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.setValueAt(1, 3546);
+  ```
+
+
+### getValueAt
+
+getValueAt(index: number): V
+
+获取LightWeightMap中具体位置键值对中的值
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定查询数据下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | V | 返回指定位置中键值对的值 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.getValueAt(1);
+  ```
+
+
+### clear
+
+clear(): void
+
+清除LightWeightMap中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  lightweightmap.clear();
+  ```
+
+
+### keys
+
+keys(): IterableIterator<K>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[K,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  let itor = lightweightmap.keys();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  }
+  ```
+
+
+### values
+
+values(): IterableIterator<V>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[V,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  let itor = lightweightmap.values();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  } 
+  ```
+
+
+### forEach
+
+forEach(callbackfn: (value: V, key?: K, lightweightmap?: LightWeightMap<K, V>) => void, thisArg?: Object): void 
+
+通过回调函数来遍历实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | V | 是 | 当前遍历到的元素键值对的值。 |
+  | key | K | 是 | 当前遍历到的元素键值对的键。 |
+  | lightweightmap | LightWeightMap<K, V> | 否 | 当前调用forEach方法的实例对象。 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("sdfs", 123);
+  lightweightmap.set("dfsghsf", 357);
+  lightweightmap.forEach((value, key)=>{
+    console.log(value, key)
+  });
+  ```
+
+
+### entries
+
+entries(): IterableIterator<[K, V]>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[K, V],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  let itor = lightweightmap.entries();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp.key);
+    console.log(temp.value);
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<[K, V]>
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[K, V],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例：
+  ```
+  let lightweightmap = new LightWeightMap();
+  lightweightmap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightweightmap.set("sdfs", 356);
+  for (let item of lightweightmap) { 
+    console.log("key: " + item.key);
+    console.log("value: " + item.value);
+  }
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-lightweightset.md

+# 非线性容器LightWeightSet
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import lightweightset from '@ohos.lightweightset'  
+```
+
+
+## 权限
+
+无
+
+## LightWeightSet
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | LightWeightSet 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是LightWeightSet的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let lightweightset = new LightWeightSet();
+  ```
+
+
+### isEmpty
+
+isEmpty(): boolean 
+
+判断该容器是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const lightweightset = new LightWeightSet();
+  lightweightset.isEmpty();
+
+  ```
+
+### add
+
+add(value: T): boolean;
+
+向此容器中添加数据
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 添加的成员数据。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否成功添加元素 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  ```
+
+
+### addAll
+
+addAll(set: LightWeightSet<T>): boolean;
+
+将另一个容器中的所有元素组添加到当前容器中
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | set | LightWeightSet<T> | 是 | 提供添加元素的lightweightmap |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  let set = new LightWeightSet();
+  set.add("sfage");
+  lightweightset.addAll(set);
+  ```
+
+
+### hasAll
+
+hasAll(set: LightWeightSet<T>): boolean;
+
+判断此容器中是否含有该指定set中的所有元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | set | LightWeightSet<T> | 是 | 比较对象 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含所有元素 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  let set = new LightWeightSet();
+  set.add("sdfs");
+  let result = lightweightset.hasAll(set);
+  ```
+
+
+### has
+
+has(value: T): boolean
+
+判断此容器中是否含有该指定value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.has(123);
+  lightweightset.add(123);
+  lightweightset.has(123);
+  ```
+
+
+### equal
+
+equal(obj: Object): boolean
+
+判断此容器中是否含有该指定obj同类型
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | obj | Object | 是 | 比较对象 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否构成类型相同 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  let obj = {"Ahfbrgrbgnutfodgorrogorgrogofdfdf", "sdfs"}
+  let result = lightweightset.equal(obj);
+  ```
+
+
+### ensureCapacityTo
+
+ensureCapacityTo(minimumCapacity: number): void
+
+将当前容器扩容至可以容纳指定数量元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | minimumCapacity | number | 是 | 需要容纳数量 |
+
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.ensureCapacityTo(10);
+  ```
+
+
+### getIndexOf
+
+getIndexOf(key: T): number
+
+获取指定key所对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | T | 是 | 查找的指定key |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 在lightweightset中指定数据的下标 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  lightweightset.getIndexOf("sdfs");
+  ```
+
+
+### remove
+
+remove(key: T): T;
+
+删除指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | T | 是 | 依据key指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除元素的值 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  lightweightset.remove("sdfs");
+  ```
+
+
+### removeAt
+
+removeAt(index: number): boolean;
+
+删除指定下标的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定想要删除元素下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 确认是否成功删除元素 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  lightweightset.removeAt(1);
+  ```
+
+
+### getValueAt
+
+getValueAt(index: number): T
+
+获取此容器中具体位置的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定查询数据下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回指定位置中元素 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  lightweightset.getValueAt(1);
+  ```
+
+
+### clear
+
+clear(): void
+
+清除容器中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  lightweightset.clear();
+  ```
+
+
+### toString
+
+toString(): String
+
+获取包含容器中所有键和值的字符串
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | String | 返回一个字符串。 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  lightweightset.toString();
+  ```
+
+
+### toArray
+
+toArray(): Array<T>
+
+获取包含此容器中所有对象的数组
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Array<T> | 返回一个数组 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  lightweightset.toString();
+  ```
+
+
+### values
+
+values(): IterableIterator<T>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  let itor = lightweightset.values();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  } 
+  ```
+
+
+### forEach
+
+forEach(callbackfn: (value: T, key?: T, lightweightset?: LightWeightSet<T>) => void, thisArg?: Object): void 
+
+通过回调函数来遍历LightWeightSet实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | key | T | 否 | 当前遍历到的元素（和value相同）。 |
+  | lightweightset | LightWeightSet<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("sdfs");
+  lightweightset.add("dfsghsf");
+  lightweightset.forEach((value, key)=>{
+    console.log(value, key)
+  });
+  ```
+
+
+### entries
+
+entries(): IterableIterator<[T, T]>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[T, T],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  let itor = lightweightset.entries();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp.key);
+    console.log(temp.value);
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例：
+  ```
+  let lightweightset = new LightWeightSet();
+  lightweightset.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightweightset.add("sdfs");
+  for (let item of lightweightset) { 
+    console.log("value: " + item);
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-linkedlist.md

+# 线性容器LinkedList
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import LinkedList from '@ohos.linkedlist'  
+```
+
+
+## 权限
+
+无
+
+
+## LinkedList
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | 获取LinkedList 的元素个数 |
+
+
+### constructor
+
+constructor(_head?: NodeObj<T>, _tail?: NodeObj<T>) 
+
+constructor是LinkedList的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | _head | NodeObj<T> | 是 | 否 | 入参对象,节点对象,含有element,和next指向,和prev指向 |
+  | _tail | NodeObj<T> | 是 | 否 | 入参对象,节点对象,含有element,和next指向,和prev指向 |
+
+- 示例：
+  ```
+  let linkedlist = new LinkedList();
+  ```
+
+
+### add
+
+add(element: T): boolean
+
+在LinkedList尾部插入元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 插入成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList;
+  linkedlist.add("a");
+  linkedlist.add(1);
+  let b = [1,2,3];
+  linkedlist.add(b);
+  let c = {name:"lala",age:"13"};
+  linkedlist.add(false)
+  ```
+### addFirst
+
+addFirst(element: T): void
+
+在LinkedList头部插入元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList;
+  linkedlist.addFirst("a");
+  linkedlist.addFirst(1);
+  let b = [1,2,3];
+  linkedlist.addFirst(b);
+  let c = {name:"lala",age:"13"};
+  linkedlist.addFirst(false)
+  ```
+
+### insert
+
+insert(element: T, index: number): void
+
+在长度范围内任意插入指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被插入的元素 |
+  | index | number | 是 | 被插入的元素 |
+
+- 示例:
+  ```
+  let linkedlist = new LinkedList
+  linkedlist.insert("A",0);
+  linkedlist.insert(0,1);
+  linkedlist.insert(true,2);
+
+  ```
+
+### has
+
+has(element: T): boolean
+
+判断此LinkedList中是否含有该指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList()
+  linkedlist.has("Ahfbrgrbgnutfodgorrogorg");
+  linkedlist.add("Ahfbrgrbgnutfodgorrogorg");
+  linkedlist.has("Ahfbrgrbgnutfodgorrogorg");
+
+  ```
+
+### get
+
+get(index: number): T  
+
+根据下标获取LinkedList中的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 要查找的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 根据下标查找到的元素 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(2);
+  linkedlist.add(1);
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.get(2);
+
+  ```
+### getLastIndexOf
+
+getLastIndexOf(element: T): number
+
+查找指定元素最后一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回最后一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(2);
+  linkedlist.add(1);
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.getLastIndexOf(2);
+
+  ```
+
+### getIndexOf
+
+getIndexOf(element: T): number
+
+查找指定元素第一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回第一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(2);
+  linkedlist.add(1);
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.getIndexOf(2);
+
+  ```
+### removeByIndex
+
+removeByIndex(index: number): T
+
+根据下标删除元素并返回该删除元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 删除元素的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.removeByIndex(2);
+
+  ```
+### removeFirst
+
+removeFirst(): T
+
+删除并返回LinkedList的首元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.removeFirst();
+
+  ```
+### removeLast
+
+removeLst(): T
+
+删除并返回LinkedList的尾元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.removeLast();
+
+  ```
+
+### remove
+
+remove(element: T): boolean
+
+删除查找到的第一个指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 删除成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.remove(2);
+
+  ```
+### removeFirstFound
+
+removeFirstFound(element: T): boolean
+
+删除第一次出现的指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 删除成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.removeFirstFound(4);
+
+  ```
+### removeLastFound
+
+removeLastFound(element: T): boolean
+
+删除最后一次出现的指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 删除成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.removeLastFound(4);
+
+  ```
+### clone
+clone(): LinkedList<T> 
+
+克隆一个与LinkedList一模一样的实例,并返回克隆后的实例,修改克隆后的实例并不会影响原实例
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | LinkedList<T> | 返回LinkedList对象实例 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.clone();
+ 
+  ```
+### forEach
+forEach(callbackfn: (value: T, index?: number, linkedlist?: LinkedList<T>) => void,
+thisArg?: Object): void 
+
+通过回调函数来遍历LinkedList实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | linkedlist | LinkedList<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.forEach((value,index)=>{
+    console.log(value,index)
+  });
+
+  ```
+### clear
+clear(): void
+
+清除LinkedList中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.clear();
+ 
+  ```
+### set
+set(index: number, element: T): T
+将此 LinkedList 中指定位置的元素替换为指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 查找的下标 |
+  | element | T | 是 | 用来替换的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T类型 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.set(2,"b");
+ 
+  ```
+### convertToArray
+convertToArray(): Array<T>
+
+把当前LinkedList实例转换成数组,并返回转换后的数组
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Array<T> | 返回数组类型 |
+
+- 示例:
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.convertToArray();
+
+  ```
+
+### getFirst
+
+getFirst(): T
+获取LinkedList实例中的第一个元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.getFirst();
+  ```
+### getLast
+
+getLast(): T 
+获取LinkedList实例中的最后一个元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  linkedlist.getLast();
+  ```
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  const linkedlist = new LinkedList();
+  linkedlist.add(2);
+  linkedlist.add(4);
+  linkedlist.add(5);
+  linkedlist.add(4);
+  for (let item of linkedlist) { 
+    console.log(item); 
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-list.md

+# 线性容器List
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import List from '@ohos.list'  
+```
+
+
+## 权限
+
+无
+
+
+## List
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | 获取List 的元素个数 |
+
+
+### constructor
+
+constructor(_head?: NodeObj<T>) 
+
+constructor是List的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | _head | NodeObj<T> | 是 | 否 | 入参对象,节点对象,含有element,和next指向 |
+
+- 示例：
+  ```
+  let list = new List();
+  ```
+
+
+### add
+
+add(element: T): boolean
+
+在List尾部插入元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 插入成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const list = new List;
+  list.add("a");
+  list.add(1);
+  let b = [1,2,3];
+  list.add(b);
+  let c = {name:"lala",age:"13"};
+  list.add(false)
+  ```
+
+### insert
+
+insert(element: T, index: number): void
+
+在长度范围内任意插入指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被插入的元素 |
+  | index | number | 是 | 被插入的元素 |
+
+- 示例:
+  ```
+  let list = new List()
+  list.insert("A",0);
+  list.insert(0,1);
+  list.insert(true,2);
+
+  ```
+
+### has
+
+has(element: T): boolean
+
+判断此List中是否含有该指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  const list = new List()
+  list.has("Ahfbrgrbgnutfodgorrogorg");
+  list.add("Ahfbrgrbgnutfodgorrogorg");
+  list.has("Ahfbrgrbgnutfodgorrogorg");
+
+  ```
+
+### get
+
+get(index: number): T  
+
+根据下标获取List中的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 要查找的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 根据下标查找到的元素 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(2);
+  list.add(1);
+  list.add(2);
+  list.add(4);
+  list.get(2);
+
+  ```
+### getLastIndexOf
+
+getLastIndexOf(element: T): number
+
+查找指定元素最后一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回最后一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(2);
+  list.add(1);
+  list.add(2);
+  list.add(4);
+  list.getLastIndexOf(2);
+
+  ```
+
+### getIndexOf
+
+getIndexOf(element: T): number
+
+查找指定元素第一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回第一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(2);
+  list.add(1);
+  list.add(2);
+  list.add(4);
+  list.getIndexOf(2);
+
+  ```
+
+### equal
+
+equal(obj: Object): boolean
+
+比较指定对象与此List是否相等。如果对象与此列表相同，返回true,否则返回false
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | obj | Object | 是 | 用来比较的对象 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 返回boolean类型 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(2);
+  const obj1 = new List();
+  obj1.add(2);
+  obj1.add(4);
+  obj1.add(5);
+  list.equal(obj1);
+  const obj2 = {name: "lala", age: "13"};
+  list.equal(obj2);
+  ```
+### removeByIndex
+
+removeByIndex(index: number): T
+
+根据下标删除元素并返回该删除元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 删除元素的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(2);
+  list.add(4);
+  list.removeByIndex(2);
+
+  ```
+
+### remove
+
+remove(element: T): boolean
+
+删除查找到的第一个指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 删除成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.remove(2);
+
+  ```
+
+### replaceAllElements
+replaceAllElements(callbackfn: (value: T, index?: number, list?: List<T>) => T,
+thisArg?: Object): void
+
+用户操作List中的元素,用操作后的元素替换原元素并返回操作后的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | list | List<T> | 否 | 当前调用replaceAllElements方法的实例对象。 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.replaceAllElements((value,index)=>{
+    return value = 2*value;
+  });
+  list.replaceAllElements((value,index)=>{
+    return value = value - 2;
+  });
+
+  ```
+### forEach
+forEach(callbackfn: (value: T, index?: number, list?: List<T>) => void,
+thisArg?: Object): void 
+
+通过回调函数来遍历List实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | list | List<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.forEach((value,index)=>{
+    console.log(value,index)
+  });
+
+  ```
+### sort
+sort(comparator: (firstValue: T, secondValue: T) => number): void
+ 
+对List中的元素进行一个排序操作
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | comparator | function | 是 | 回调函数。 |
+
+- comparator的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | firstValue | T | 是 | 前一项元素 |
+  | secondValue | T | 是 | 后一项元素 |
+ 
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.sort(a,b=>a-b);
+  list.sort(a,b=>b-a);
+
+  ```
+### getSubList
+getSubList(fromIndex: number, toIndex: number): List<T>
+
+根据下标截取List中的一段元素,并返回这一段list实例,包前不包后
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | fromIndex | number | 是 | 起始下标 |
+  | toIndex | number | 是 | 终止下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | List<T> | 返回List对象实例 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.subList(2,4);
+  list.subList(4,3);
+  list.subList(2,6);
+ 
+  ```
+
+### clear
+clear(): void
+
+清除List中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.clear();
+ 
+  ```
+### set
+set(index: number, element: T): T
+将此 List 中指定位置的元素替换为指定元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 查找的下标 |
+  | element | T | 是 | 用来替换的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T类型 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.set(2,"b");
+ 
+  ```
+### convertToArray
+convertToArray(): Array<T>
+
+把当前List实例转换成数组,并返回转换后的数组
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Array<T> | 返回数组类型 |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.convertToArray();
+
+  ```
+### isEmpty
+isEmpty(): boolean 
+
+判断该List是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.isEmpty();
+
+  ```
+### getFirst
+
+getFirst(): T
+获取List实例中的第一个元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  const list = new Vector();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.getFirst();
+  ```
+### getLast
+
+getLast(): T 
+获取List实例中的最后一个元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  const list = new Vector();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.getLast();
+  ```
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  const list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  for (let item of list) { 
+    console.log(item); 
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-plainarray.md

+# 非线性容器PlainArray
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import plainarray from '@ohos.plainarray'  
+```
+
+
+## 权限
+
+无
+
+## PlainArray
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | PlainArray 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是PlainArray的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let plainarray = new PlainArray();
+  ```
+
+
+### isEmpty
+
+isEmpty(): boolean 
+
+判断该容器是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const plainarray = new PlainArray();
+  plainarray.isEmpty();
+  ```
+
+
+### has
+
+has(key: number): boolean
+
+判断此容器中是否含有该指定key
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | number | 是 | 查询的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray()
+  plainarray.has(1);
+  plainarray.add(1, "sddfhf");
+  plainarray.has(1);
+  ```
+
+
+### get
+
+get(key: number): T
+
+获取指定key所对应的value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | number | 是 | 查找的指定key |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回key映射的value值 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.get(1);
+  ```
+
+
+### getIndexOfKey
+
+getIndexOfKey(key: number): number
+
+查找指定元素第一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | number | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回第一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.getIndexOfKey("sdfs");
+  ```
+
+
+### getIndexOfValue
+
+getIndexOfValue(value: T): number
+
+查找指定元素第一次出现的下标值,如果没有找到该元素返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 被查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回第一次找到指定元素的下标,没有找到返回-1 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.getIndexOfValue("sddfhf");
+  ```
+
+
+### getKeyAt
+
+getKeyAt(index: number): number
+
+查找指定下标的元素键值对中key值，否则返回undefined
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 所查找的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回该下标对应的元素键值对中key值 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.getKeyAt(1);
+  ```
+
+
+### clone
+
+clone(): PlainArray<T>
+
+克隆一个一模一样的实例,并返回克隆后的实例,修改克隆后的实例并不会影响原实例
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | PlainArray<T> | 返回新的对象实例 |
+
+- 示例:
+  ```
+  let plainarray = new ArrayList();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  let newPlainArray = plainarray.clone();
+  ```
+
+
+### add
+
+add(key: number, value: T): boolean;
+
+向容器中添加一组数据
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | number | 是 | 添加成员数据的键名。 |
+  | value | T | 是 | 添加成员数据的值。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 确认是否成功添加 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  ```
+
+
+### remove
+
+remove(key: number): T;
+
+删除指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | number | 是 | 依据key指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除元素的值 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.remove(2);
+  ```
+
+
+### removeAt
+
+removeAt(index: number): boolean;
+
+删除指定下标的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定想要删除元素下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 确认是否成功删除元素 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.removeAt(1);
+  ```
+
+
+### removeRangeFrom
+
+removeRangeFrom(index: number, size: number): number
+
+删除一定范围内的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 删除元素的起始下标 |
+  | size | number | 是 | 期望删除元素个数 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 实际删除元素个数 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.removeAt(1, 3);
+  ```
+
+
+### setValueAt
+
+setValueAt(index: number, newValue: T): void
+
+向容器中具体位置替换键值对中的值
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定替换数据下标 |
+  | newValue | T | 是 | 替换键值对中的值 |
+
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.setValueAt(1, 3546);
+  ```
+
+
+### toString
+
+toString(): String
+
+获取包含容器中所有键和值的字符串
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | String | 返回一个字符串。 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.toString();
+  ```
+
+
+### clear
+
+clear(): void
+
+清除容器中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.clear();
+  ```
+
+
+### forEach
+
+forEach(callbackfn: (value: T, key?: number, plainarray?: PlainArray<number, T>) => void, thisArg?: Object): void 
+
+通过回调函数来遍历实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素键值对的值。 |
+  | key | number | 是 | 当前遍历到的元素键值对的键。 |
+  | plainarray | PlainArray<number, T> | 否 | 当前调用forEach方法的实例对象。 |
+
+- 示例:
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  plainarray.forEach((value, key)=>{
+    console.log(value, key)
+  });
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<[number, T]>
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[number, T],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例：
+  ```
+  let plainarray = new PlainArray();
+  plainarray.add(1, "sddfhf");
+  plainarray.add(2, "sffdfhf");
+  for (let item of plainarray) { 
+    console.log("key: " + item.key);
+    console.log("value: " + item.value);
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-queue.md

+#  线性容器Queue
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import Queue from '@ohos.queue'  
+```
+
+
+## 权限
+
+无
+
+
+## Queue
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | 获取Queue 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是Queue的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let queue = new Queue();
+  ```
+
+
+### add
+
+add(element: T): boolean
+
+在队列尾部插入元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 插入成功返回true,失败返回false |
+
+- 示例:
+  ```
+  const queue = new Queue();
+  queue.add("a");
+  queue.add(1);
+  let b = [1,2,3];
+  queue.add(b);
+  let c = {name:"lala",age:"13"};
+  queue.add(false)
+  ```
+
+### pop
+
+pop(): T
+
+删除头元素并返回该删除元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const queue = new Queue();
+  queue.add(2);
+  queue.add(4);
+  queue.add(5);
+  queue.add(2);
+  queue.add(4);
+  queue.pop();
+
+  ```
+
+### getFirst
+
+getFirst(): T 
+
+获取队列的头元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回尾元素 |
+
+- 示例:
+  ```
+  const queue = new Queue();
+  queue.add(2);
+  queue.add(4);
+  queue.add(5);
+  queue.add(2);
+  queue.getFirst();
+
+  ```
+
+### forEach
+forEach(callbackfn: (value: T, index?: number, queue?: Queue<T>) => void,
+thisArg?: Object): void 
+
+通过回调函数来遍历Queue实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | queue | Queue<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+
+- 示例:
+  ```
+  const queue = new Queue();
+  queue.add(2);
+  queue.add(4);
+  queue.add(5);
+  queue.add(4);
+  queue.forEach((value,index)=>{
+    console.log(value,index)
+  });
+
+  ```
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  const queue = new Queue();
+  queue.add(2);
+  queue.add(4);
+  queue.add(5);
+  queue.add(4);
+   for (let item of queue) { 
+    console.log(item); 
+  } 
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-stack.md

+# 线性容器Stack
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import Stack from '@ohos.stack'  
+```
+
+
+## 权限
+
+无
+
+
+## Stack
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | 获取Stack 的元素个数 |
+
+
+### constructor
+
+constructor()
+
+constructor是Stack的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | 无 | 无 | 是 | 否 | 无 |
+
+- 示例：
+  ```
+  let stack = new Stack();
+  ```
+
+
+### push
+
+push(item: T): T
+
+在栈顶插入元素,并返回该元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回被添加进去的元素 |
+
+- 示例:
+  ```
+  const stack = new Stack();
+  stack.push("a");
+  stack.push(1);
+  let b = [1,2,3];
+  stack.push(b);
+  let c = {name:"lala",age:"13"};
+  stack.push(false)
+  ```
+
+### pop
+
+pop(): T
+
+删除栈顶元素并返回该删除元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  const stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(2);
+  stack.push(4);
+  stack.pop();
+
+  ```
+
+### peek
+
+peek(): T
+
+获取并返回栈顶元素
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回栈顶元素 |
+
+- 示例:
+  ```
+  const stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(2);
+  stack.peek();
+
+  ```
+### locate
+
+locate(element: T): number 
+
+获取指定元素第一次出现的下标,找到就返回下标值,没有找到就返回-1
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 查找的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 找到就返回下标值,没有找到返回-1 |
+- 示例:
+  ```
+  const stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(2);
+  stack.locate(2);
+
+  ```
+
+### forEach
+forEach(callbackfn: (value: T, index?: number, stack?: Stack<T>) => void,
+thisArg?: Object): void 
+
+通过回调函数来遍历Stack实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素。 |
+  | index | number | 否 | 当前遍历到的下标值。 |
+  | stack | Stack<T> | 否 | 当前调用forEach方法的实例对象。 |
+
+
+- 示例:
+  ```
+  const stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(4);
+  stack.forEach((value,index)=>{
+   console.log(value,index)
+  });
+
+  ```
+### isEmpty
+isEmpty(): boolean 
+
+判断该栈是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(4);
+  stack.isEmpty();
+
+  ```
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<T>
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[T,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  const stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(4);
+  for (let item of stack) { 
+    console.log(item); 
+  }
+  
+  ```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-treemap.md

+# 非线性容器TreeMap
+
+> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+
+
+## 导入模块
+
+```
+import treemap from '@ohos.treemap'  
+```
+
+
+## 权限
+
+无
+
+## TreeMap
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | TreeMap 的元素个数 |
+
+
+### constructor
+
+constructor(comparator?:(firstValue: K, secondValue: K) => boolean)
+
+constructor是TreeMap的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | comparator | function | 否 | 用户自定义的比较函数 |
+
+- 示例：
+  ```
+  let treemap = new TreeMap();
+  ```
+
+
+### isEmpty
+
+isEmpty(): boolean 
+
+判断该容器是否为空
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  const treemap = new TreeMap();
+  treemap.isEmpty();
+  ```
+
+
+### hasKey
+
+hasKey(key: K): boolean
+
+判断此容器中是否含有该指定key
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.hasKey("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.hasKey("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  ```
+
+
+### hasValue
+
+hasValue(value: V): boolean
+
+判断此容器中是否含有该指定value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | V | 是 | 是否包含的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.hasValue(123);
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.hasValue(123);
+  ```
+
+
+### get
+
+get(key: K): V
+
+获取指定key所对应的value
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 查找的指定key |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | V | 返回key映射的value值 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  treemap.get("sdfs");
+  ```
+
+
+### getFirstKey
+
+getFirstKey(): K
+
+获取容器中排序第一的数据
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | K | 返回排序第一的数据 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  let result = treemap.getFirstKey();
+  ```
+
+
+### getLastKey
+
+getLastKey(): K
+
+获取容器中排序最后的数据
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | K | 返回排序最后的数据 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  let result = treemap.getLastKey();
+  ```
+
+
+### setAll
+
+setAll(map: TreeMap<K, V>): void
+
+将一个treemap中的所有元素组添加到另一个treemap中
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | map | TreeMap<K, V> | 是 | 被添加元素的treemap |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  let map = new TreeMap();
+  treemap.setAll(map);
+  ```
+
+
+### set
+set(key: K, value: V): Object;
+
+向treemap中添加一组数据
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 添加成员数据的键名。 |
+  | value | V | 是 | 添加成员数据的值。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Object | 返回添加后的hashmap |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  ```
+
+
+### remove
+
+remove(key: K): V;
+
+删除指定的元素
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 依据key指定删除的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | V | 返回删除元素的值 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  treemap.remove("sdfs");
+  ```
+
+
+### getLowerByKey
+
+getLowerByKey(key: K): K;
+
+获取容器中比传入key排序靠前一位的key
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 对比的key值 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | K | 返回排序中key前一位的数据 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  treemap.set("zdfgsd", 356);
+  let result = treemap.getLowerByKey("sdfs");
+  ```
+
+
+### getHigherByKey
+
+getHigherByKey(key: K): K;
+
+获取容器中比传入key排序靠后一位的key
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 对比的key值 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | K | 返回排序中key后一位的数据 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  treemap.set("zdfgsd", 356);
+  let result = treemap.getHigherByKey("sdfs");
+  ```
+
+
+### replace
+replace(key: K, value: V): boolean;
+
+对TreeMap中一组数据进行更新（替换）
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | key | K | 是 | 依据key指定替换的元素。 |
+  | value | V | 是 | 添加成员数据的值。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 是否成功对已有数据进行替换 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("sdfs", 123);
+  treemap.replace("sdfs", 357);
+  ```
+
+
+### clear
+
+clear(): void
+
+清除TreeMap中的所有元素,并把length置为0
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  treemap.clear();
+  ```
+
+
+### keys
+
+keys(): IterableIterator<K>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[K,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  let itor = treemap.keys();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  } 
+  ```
+
+
+### values
+
+values(): IterableIterator<V>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[V,&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  let itor = treemap.values();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp);
+  }
+  ```
+
+
+### forEach
+
+forEach(callbackfn: (value: V, key?: K, treemap?: TreeMap<K, V>) => void, thisArg?: Object): void 
+
+通过回调函数来遍历实例对象上的元素以及元素对应的下标
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数。 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | V | 是 | 当前遍历到的元素键值对的值。 |
+  | key | K | 是 | 当前遍历到的元素键值对的键。 |
+  | treemap | TreeMap<K, V> | 否 | 当前调用forEach方法的实例对象。 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("sdfs", 123);
+  treemap.set("dfsghsf", 357);
+  treemap.forEach((value, key)=>{
+    console.log(value, key)
+  });
+  ```
+
+
+### entries
+
+entries(): IterableIterator<[K, V]>
+
+返回包含此映射中包含的键的新迭代器对象
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[K, V],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例:
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  let itor = treemap.entries();
+  while(itor.next() != undefined) {
+    let temp = itor.next();
+    console.log(temp.key);
+    console.log(temp.value);
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator](): IterableIterator<[K, V]>
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;[[K, V],&nbsp;boolean]&gt; | 返回一个迭代器。 |
+
+- 示例：
+  ```
+  let treemap = new TreeMap();
+  treemap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treemap.set("sdfs", 356);
+  for (let item of treemap) { 
+    console.log("key: " + item.key);
+    console.log("value: " + item.value);
+  } 
+  ```
\ No newline at end of file