!1310 add containers class API interface reference description

Merge pull request !1310 from parrotli/linhaoran

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

@@ -76,4 +76,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.util.ArrayList'
+```
+
+## 权限
+
+无
+
+## ArrayList
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | ArrayList的元素个数 |
+
+
+### constructor
+
+constructor();
+
+ArrayList的构造函数。
+
+- 示例：
+  ```
+  let arrayList = new ArrayList();
+  ```
+
+
+### add
+
+add(element: T): boolean;
+
+在ArrayList尾部插入元素。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 插入成功返回true,失败返回false |
+
+- 示例:
+  ```
+  let 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 | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let arrayList = new ArrayList();
+  arrayList.has("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  arrayList.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  arrayList.has("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  ```
+
+### getIndexOf
+
+getIndexOf(element: T): number;
+
+返回指定元素第一次出现时的下标值，查找失败返回-1。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 指定元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回指定元素第一次出现时的下标值，查找失败返回-1 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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 | 返回删除的元素 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例：
+  ```
+  let 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 | 是 | 终止下标 |
+
+- 示例:
+  ```
+  let 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方法的实例对象 |
+
+- 示例:
+  ```
+  let 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方法的实例对象。 |
+
+
+- 示例:
+  ```
+  let 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 | 是 | 后一项元素 |
+ 
+
+- 示例:
+  ```
+  let 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对象实例 |
+
+- 示例:
+  ```
+  let 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。
+
+- 示例:
+  ```
+  let 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对象实例 |
+
+- 示例:
+  ```
+  let arrayList = new ArrayList();
+  arrayList.add(2);
+  arrayList.add(4);
+  arrayList.add(5);
+  arrayList.add(4);
+  arrayList.clone();
+  ```
+### getCapacity
+getCapacity(): number;
+
+获取当前实例的容量大小。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | number | 返回arraylist的容量大小 |
+
+- 示例:
+  ```
+  let arrayList = new ArrayList();
+  arrayList.add(2);
+  arrayList.add(4);
+  arrayList.add(5);
+  arrayList.add(4);
+  arrayList.getCapacity();
+  ```
+### convertToArray
+convertToArray(): Array<T>;
+
+把当前ArrayList实例转换成数组,并返回转换后的数组。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Array<T> | 返回数组类型 |
+
+- 示例:
+  ```
+  let arrayList = new ArrayList();
+  arrayList.add(2);
+  arrayList.add(4);
+  arrayList.add(5);
+  arrayList.add(4);
+  arrayList.convertToArray();
+  ```
+### isEmpty
+isEmpty(): boolean;
+
+判断该ArrayList是否为空。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  let arrayList = new ArrayList();
+  arrayList.add(2);
+  arrayList.add(4);
+  arrayList.add(5);
+  arrayList.add(4);
+  arrayList.isEmpty();
+  ```
+### increaseCapacityTo
+increaseCapacityTo(newCapacity: number): void;
+
+如果传入的新容量大于或等于ArrayList中的元素个数，将容量变更为新容量。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | newCapacity | number | 是 | 新容量 |
+
+
+- 示例:
+  ```
+  let 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大小。
+
+- 示例:
+  ```
+  let 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<T> | 返回一个迭代器 |
+
+- 示例：
+  ```
+  let arrayList = new ArrayList();
+  arrayList.add(2);
+  arrayList.add(4);
+  arrayList.add(5);
+  arrayList.add(4);
+
+  // 使用方法一：
+  for (let item of arrayList) { 
+    console.log(item); 
+  } 
+
+  // 使用方法二：
+  let iter = arrayList[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.Deque'  
+```
+
+## 权限
+
+无
+
+## Deque
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | Deque的元素个数 |
+
+### constructor
+
+constructor();
+
+Deque的构造函数。
+
+- 示例：
+  ```
+  let queue = new Queue();
+  ```
+
+### insertFront
+
+insertFront(element: T): void;
+
+在deque头部插入元素。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 示例:
+  ```
+  let 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 | 是 | 添加进去的元素 |
+
+- 示例:
+  ```
+  let 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 | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let deque = new Deque();
+  deque.has("Ahfbrgrbgnutfodgorrogorg");
+  deque.insertFront("Ahfbrgrbgnutfodgorrogorg");
+  deque.has("Ahfbrgrbgnutfodgorrogorg");
+  ```
+### popFirst
+
+popFirst(): T;
+
+删除并返回双端队列的首元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  let deque = new Deque();
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.insertEnd(5);
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.popFirst();
+  ```
+### popLast
+
+popLast(): T;
+
+删除并返回双端队列的尾元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  let 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方法的实例对象 |
+
+- 示例:
+  ```
+  let 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型 |
+
+
+- 示例：
+  ```
+  let deque = new Deque();
+  deque.insertEnd(2);
+  deque.insertEnd(4);
+  deque.insertFront(5);
+  deque.insertFront(4);
+  deque.getFirst();
+  ```
+### getLast
+
+getLast(): T;
+获取Deque实例中的尾元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  let 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<T> | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  let deque = new Deque();
+  deque.insertFront(2);
+  deque.insertFront(4);
+  deque.insertFront(5);
+  deque.insertFront(4);
+
+  // 使用方法一：
+  for (let item of deque) { 
+    console.log(item); 
+  }
+
+  // 使用方法二：
+  let iter = deque[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.HashMap'  
+```
+
+
+## 权限
+
+无
+
+## HashMap
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | HashMap的元素个数 |
+
+
+### 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&lt;K&gt;;
+
+返回包含此映射中包含的键的新迭代器对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;K&gt; | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let hashMap = new HashMap();
+  hashMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashMap.set("sdfs", 356);
+  let iter = hashMap.keys();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### values
+
+values(): IterableIterator&lt;V&gt;;
+
+返回包含此映射中包含的键的新迭代器对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;V&gt; | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let hashMap = new HashMap();
+  hashMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashMap.set("sdfs", 356);
+  let iter = hashMap.values();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### 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<[K, V]> | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let hashMap = new HashMap();
+  hashMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashMap.set("sdfs", 356);
+  let iter = hashMap.entries();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator]\(): IterableIterator&lt;[K, V]&gt;;
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator<[K, V]> | 返回一个迭代器 |
+
+- 示例：
+  ```
+  let hashMap = new HashMap();
+  hashMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  hashMap.set("sdfs", 356);
+
+  // 使用方法一：
+  for (let item of hashMap) { 
+    console.log("key: " + item[0]);
+    console.log("value: " + item[1]);
+  }
+
+  // 使用方法二：
+  let iter = hashMap[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().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.util.HashSet'  
+```
+
+
+## 权限
+
+无
+
+## HashSet
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | HashSet的元素个数 |
+
+
+### 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;
+
+判断此HashSet中是否含有该指定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<T> | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let hashSet = new HashSet();
+  hashSet.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashSet.add("sdfs");
+  let iter = hashSet.values();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  } 
+  ```
+
+
+### 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<[T, T]> | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let hashSet = new HashSet();
+  hashSet.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashSet.add("sdfs");
+  let iter = hashSet.entries();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator]\(): IterableIterator&lt;T&gt;;
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;T&gt; | 返回一个迭代器 |
+
+- 示例：
+  ```
+  let hashSet = new HashSet();
+  hashSet.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  hashSet.add("sdfs");
+
+  // 使用方法一：
+  for (let item of hashSet) { 
+    console.log("value: " + item);
+  }
+
+  // 使用方法二：
+  let iter = hashSet[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.LightWeightMap'  
+```
+
+
+## 权限
+
+无
+
+## LightWeightMap
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | LightWeightMap的元素个数 |
+
+
+### 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&lt;K&gt;;
+
+返回包含此映射中包含的键的新迭代器对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;K&gt; | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let lightWeightMap = new LightWeightMap();
+  lightWeightMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightWeightMap.set("sdfs", 356);
+  let iter = lightWeightMap.keys();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### values
+
+values(): IterableIterator&lt;V&gt;;
+
+返回包含此映射中包含的键的新迭代器对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;V&gt; | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let lightWeightMap = new LightWeightMap();
+  lightWeightMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightWeightMap.set("sdfs", 356);
+  let iter = lightWeightMap.values();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  } 
+  ```
+
+
+### 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<[K, V]> | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let lightWeightMap = new LightWeightMap();
+  lightWeightMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightWeightMap.set("sdfs", 356);
+  let iter = lightWeightMap.entries();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator]\(): IterableIterator&lt;[K, V]&gt;;
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator<[K, V]> | 返回一个迭代器 |
+
+- 示例：
+  ```
+  let lightWeightMap = new LightWeightMap();
+  lightWeightMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  lightWeightMap.set("sdfs", 356);
+
+  // 使用方法一：
+  for (let item of lightWeightMap) { 
+    console.log("key: " + item[0]);
+    console.log("value: " + item[1]);
+  }
+
+  // 使用方法二：
+  let iter = lightWeightMap[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().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.util.LightWeightSet'  
+```
+
+
+## 权限
+
+无
+
+## LightWeightSet
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | LightWeightSet的元素个数 |
+
+
+### 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<T> | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let lightWeightSet = new LightWeightSet();
+  lightWeightSet.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightWeightSet.add("sdfs");
+  let iter = lightWeightSet.values();
+  let index = 0;
+  while(index < lightWeightSet.length) {
+    console.log(JSON.stringify(iter.next().value));
+    index++;
+  }
+  ```
+
+
+### forEach
+
+forEach(callbackfn: (value: T, key?: T, lightWeightSet?: LightWeightSet&lt;T&gt;) => void, thisArg?: Object): void;
+
+通过回调函数来遍历LightWeightSet实例对象上的元素以及元素对应的下标。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | callbackfn | function | 是 | 回调函数 |
+  | thisArg | Object | 否 | callbackfn被调用时用作this值 |
+
+- callbackfn的参数说明
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | value | T | 是 | 当前遍历到的元素 |
+  | key | T | 否 | 当前遍历到的元素（和value相同） |
+  | lightWeightSet | LightWeightSet&lt;T&gt; | 否 | 当前调用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<[T, T]> | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let lightWeightSet = new LightWeightSet();
+  lightWeightSet.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightWeightSet.add("sdfs");
+  let iter = lightWeightSet.entries();
+  let index = 0;
+  while(index < lightWeightSet.length) {
+    console.log(JSON.stringify(iter.next().value));
+    index++;
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator]\(): IterableIterator&lt;T&gt;;
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;T&gt; | 返回一个迭代器 |
+
+- 示例：
+  ```
+  let lightWeightSet = new LightWeightSet();
+  lightWeightSet.add("Ahfbrgrbgnutfodgorrogorgrogofdfdf");
+  lightWeightSet.add("sdfs");
+  
+  // 使用方法一：
+  for (let item of lightWeightSet) { 
+    console.log("value: " + item);
+  }
+
+  // 使用方法二：
+  let iter = lightWeightSet[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.LinkedList'  
+```
+
+
+## 权限
+
+无
+
+
+## LinkedList
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | LinkedList的元素个数 |
+
+
+### constructor
+
+constructor(_head?: NodeObj<T>, _tail?: NodeObj<T>);
+
+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 |
+
+- 示例:
+  ```
+  let 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 | 是 | 添加进去的元素 |
+
+- 示例:
+  ```
+  let 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 | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let linkedList = new LinkedList();
+  linkedList.has("Ahfbrgrbgnutfodgorrogorg");
+  linkedList.add("Ahfbrgrbgnutfodgorrogorg");
+  linkedList.has("Ahfbrgrbgnutfodgorrogorg");
+  ```
+
+### get
+
+get(index: number): T;
+
+根据下标获取LinkedList中的元素。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定的下标值 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 根据下标查找到的元素 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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 | 返回删除的元素 |
+
+- 示例:
+  ```
+  let 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 | 返回删除的元素 |
+
+- 示例:
+  ```
+  let 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 | 返回删除的元素 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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对象实例 |
+
+- 示例:
+  ```
+  let 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方法的实例对象 |
+
+- 示例:
+  ```
+  let 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。
+
+- 示例:
+  ```
+  let 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类型 |
+
+- 示例:
+  ```
+  let 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> | 返回数组类型 |
+
+- 示例:
+  ```
+  let linkedList = new LinkedList();
+  linkedList.add(2);
+  linkedList.add(4);
+  linkedList.add(5);
+  linkedList.add(4);
+  linkedList.convertToArray();
+  ```
+
+### getFirst
+
+getFirst(): T;
+获取LinkedList实例中的第一个元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  let linkedList = new LinkedList();
+  linkedList.add(2);
+  linkedList.add(4);
+  linkedList.add(5);
+  linkedList.add(4);
+  linkedList.getFirst();
+  ```
+### getLast
+
+getLast(): T;
+获取LinkedList实例中的最后一个元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  let 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<T> | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  let linkedList = new LinkedList();
+  linkedList.add(2);
+  linkedList.add(4);
+  linkedList.add(5);
+  linkedList.add(4);
+
+  // 使用方法一：
+  for (let item of linkedList) { 
+    console.log(item); 
+  } 
+
+  // 使用方法二：
+  let iter = linkedList[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.List'  
+```
+
+
+## 权限
+
+无
+
+
+## List
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | List的元素个数 |
+
+
+### constructor
+
+constructor(_head?: NodeObj<T>);
+
+List的构造函数。
+
+- 参数：
+  | 参数名 | 类型 | 可读 | 可写 | 说明 |
+  | -------- | -------- | -------- | -------- | -------- |
+  | _head | NodeObj<T> | 是 | 否 | 入参对象,节点对象,含有element,和next指向 |
+
+- 示例：
+  ```
+  let list = new List();
+  ```
+
+
+### add
+
+add(element: T): boolean;
+
+在List尾部插入元素。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 插入成功返回true,失败返回false |
+
+- 示例:
+  ```
+  let 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 | 是否包含指定元素 |
+
+- 示例:
+  ```
+  let list = new List();
+  list.has("Ahfbrgrbgnutfodgorrogorg");
+  list.add("Ahfbrgrbgnutfodgorrogorg");
+  list.has("Ahfbrgrbgnutfodgorrogorg");
+  ```
+
+### get
+
+get(index: number): T;
+
+根据下标获取List中的元素。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 要查找的下标 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 根据下标查找到的元素 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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类型 |
+
+- 示例:
+  ```
+  let list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(2);
+  let obj1 = new List();
+  obj1.add(2);
+  obj1.add(4);
+  obj1.add(5);
+  list.equal(obj1);
+  let obj2 = {name : "lala", age : "13"};
+  list.equal(obj2);
+  ```
+### removeByIndex
+
+removeByIndex(index: number): T;
+
+根据元素的下标值查找元素，返回元素后将其删除。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | index | number | 是 | 指定元素的下标值 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回删除的元素 |
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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方法的实例对象 |
+
+- 示例:
+  ```
+  let 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方法的实例对象 |
+
+
+- 示例:
+  ```
+  let 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 | 是 | 后一项元素 |
+ 
+
+- 示例:
+  ```
+  let 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对象实例 |
+
+- 示例:
+  ```
+  let 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。
+
+- 示例:
+  ```
+  let 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类型 |
+
+- 示例:
+  ```
+  let 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> | 返回数组类型 |
+
+- 示例:
+  ```
+  let list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.convertToArray();
+  ```
+### isEmpty
+isEmpty(): boolean;
+
+判断该List是否为空。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 为空返回true, 不为空返回false |
+
+- 示例:
+  ```
+  let list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.isEmpty();
+  ```
+### getFirst
+
+getFirst(): T;
+获取List实例中的第一个元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  let list = new Vector();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+  list.getFirst();
+  ```
+### getLast
+
+getLast(): T;
+获取List实例中的最后一个元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回T型 |
+
+
+- 示例：
+  ```
+  let 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<T> | 返回一个迭代器。 |
+
+
+- 示例：
+  ```
+  let list = new List();
+  list.add(2);
+  list.add(4);
+  list.add(5);
+  list.add(4);
+
+  // 使用方法一：
+  for (let item of list) { 
+    console.log(item); 
+  }
+
+  // 使用方法二：
+  let iter = list[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.PlainArray'  
+```
+
+
+## 权限
+
+无
+
+## PlainArray
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | PlainArray的元素个数 |
+
+
+### 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&lt;[number, T]&gt;;
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator<[number, T]> | 返回一个迭代器 |
+
+- 示例：
+  ```
+  let plainArray = new PlainArray();
+  plainArray.add(1, "sddfhf");
+  plainArray.add(2, "sffdfhf");
+
+  // 使用方法一：
+  for (let item of plainArray) { 
+    console.log("index: " + item[0]);
+    console.log("value: " + item[1]);
+  }
+
+  // 使用方法二：
+  let iter = plainArray[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().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.util.Queue'  
+```
+
+
+## 权限
+
+无
+
+
+## Queue
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | Queue的元素个数 |
+
+
+### constructor
+
+constructor();
+
+Queue的构造函数。
+
+
+- 示例：
+  ```
+  let queue = new Queue();
+  ```
+
+
+### add
+
+add(element: T): boolean;
+
+在队列尾部插入元素。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | element | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | boolean | 插入成功返回true,失败返回false |
+
+- 示例:
+  ```
+  let 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 | 返回删除的元素 |
+
+- 示例:
+  ```
+  let queue = new Queue();
+  queue.add(2);
+  queue.add(4);
+  queue.add(5);
+  queue.add(2);
+  queue.add(4);
+  queue.pop();
+  ```
+
+### getFirst
+
+getFirst(): T;
+
+获取队列的头元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回尾元素 |
+
+- 示例:
+  ```
+  let 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方法的实例对象 |
+
+
+- 示例:
+  ```
+  let 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<T> | 返回一个迭代器 |
+
+
+- 示例：
+  ```
+  let queue = new Queue();
+  queue.add(2);
+  queue.add(4);
+  queue.add(5);
+  queue.add(4);
+
+  // 使用方法一：
+  for (let item of queue) { 
+    console.log(item); 
+  }
+
+  // 使用方法二：
+  let iter = queue[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.Stack'  
+```
+
+
+## 权限
+
+无
+
+
+## Stack
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | Stack的元素个数 |
+
+
+### constructor
+
+constructor();
+
+Stack的构造函数。
+
+
+- 示例：
+  ```
+  let stack = new Stack();
+  ```
+
+
+### push
+
+push(item: T): T;
+
+在栈顶插入元素,并返回该元素。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | item | T | 是 | 添加进去的元素 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回被添加进去的元素 |
+
+- 示例:
+  ```
+  let 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 | 返回删除的元素 |
+
+- 示例:
+  ```
+  let stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(2);
+  stack.push(4);
+  stack.pop();
+  ```
+
+### peek
+
+peek(): T;
+
+获取并返回栈顶元素。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | T | 返回栈顶元素 |
+
+- 示例:
+  ```
+  let 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 |
+- 示例:
+  ```
+  let 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方法的实例对象。 |
+
+
+- 示例:
+  ```
+  let 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 |
+
+- 示例:
+  ```
+  let 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<T> | 返回一个迭代器 |
+
+
+- 示例：
+  ```
+  let stack = new Stack();
+  stack.push(2);
+  stack.push(4);
+  stack.push(5);
+  stack.push(4);
+
+  // 使用方法一：
+  for (let item of stack) { 
+    console.log(item); 
+  }
+
+  // 使用方法二：
+  let iter = stack[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
\ 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.util.TreeMap'  
+```
+
+
+## 权限
+
+无
+
+## TreeMap
+
+
+### 属性
+
+| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| -------- | -------- | -------- | -------- | -------- |
+| length | number | 是 | 否 | TreeMap的元素个数 |
+
+
+### constructor
+
+constructor(comparator?:(firstValue: K, secondValue: K) => boolean);
+
+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&lt;K&gt;;
+
+返回包含此映射中包含的键的新迭代器对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;K&gt; | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let treeMap = new TreeMap();
+  treeMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treeMap.set("sdfs", 356);
+  let iter = treeMap.keys();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  } 
+  ```
+
+
+### values
+
+values(): IterableIterator&lt;V&gt;;
+
+返回包含此映射中包含的键的新迭代器对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator&lt;V&gt; | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let treeMap = new TreeMap();
+  treeMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treeMap.set("sdfs", 356);
+  let iter = treeMap.values();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### 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<[K, V]> | 返回一个迭代器 |
+
+- 示例:
+  ```
+  let treeMap = new TreeMap();
+  treeMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treeMap.set("sdfs", 356);
+  let iter = treeMap.entries();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().value;
+  }
+  ```
+
+
+### [Symbol.iterator]
+
+[Symbol.iterator]\(): IterableIterator&lt;[K, V]&gt;;
+
+
+返回一个迭代器，迭代器的每一项都是一个 JavaScript 对象,并返回该对象。
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | IterableIterator<[K, V]> | 返回一个迭代器 |
+
+- 示例：
+  ```
+  let treeMap = new TreeMap();
+  treeMap.set("Ahfbrgrbgnutfodgorrogorgrogofdfdf", 123);
+  treeMap.set("sdfs", 356);
+  
+  // 使用方法一：
+  for (let item of treeMap) { 
+    console.log("key: " + item[0]);
+    console.log("value: " + item[1]);
+  }
+
+  // 使用方法二：
+  let iter = treeMap[Symbol.iterator]();
+  let temp = iter.next().value;
+  while(temp != undefined) {
+    console.log(temp[0]);
+    console.log(temp[1]);
+    temp = iter.next().value;
+  }
+  ```
\ No newline at end of file