diff --git a/.bundle.json.swp b/.bundle.json.swp
new file mode 100644
index 0000000000000000000000000000000000000000..c1a189e5967a2f0d49e67220c933f83b21470487
Binary files /dev/null and b/.bundle.json.swp differ
diff --git a/container/arraylist/js_arraylist.ts b/container/arraylist/js_arraylist.ts
index bd7368e270b242b2ffa1bccae89f6aca3da11f3b..a1b629b2800170baffffe252d7aba09618143639 100644
--- a/container/arraylist/js_arraylist.ts
+++ b/container/arraylist/js_arraylist.ts
@@ -136,11 +136,16 @@ if (flag || fastArrayList == undefined) {
       }
       return -1;
     }
-    removeByIndex(index: number): void {
+    removeByIndex(index: number): T {
+      if (index < 0 || index >= this._length) {
+        throw new Error("removeByIndex is out-of-bounds");
+      }
+      let result = this[index];
       for (let i = index; i < this._length - 1; i++) {
         this[i] = this[i + 1];
       }
       this._length--;
+      return result;
     }
     remove(element: T): boolean {
       if (this.has(element)) {
@@ -232,7 +237,10 @@ if (flag || fastArrayList == undefined) {
       if (fromIndex >= toIndex) {
         throw new Error(`fromIndex cannot be less than or equal to toIndex`);
       }
-      toIndex = toIndex >= this._length - 1 ? this._length - 1 : toIndex;
+      if (fromIndex >= this._length || fromIndex < 0 || toIndex < 0) {
+        throw new Error(`fromIndex or toIndex is out-of-bounds`);
+      }
+      toIndex = toIndex > this._length ? this._length - 1 : toIndex;
       let arraylist = new ArrayList<T>();
       for (let i = fromIndex; i < toIndex; i++) {
         arraylist.add(this[i]);
diff --git a/container/hashmap/js_hashmap.ts b/container/hashmap/js_hashmap.ts
index 4e2b84c2e7985992d8aeabff80a9dfa6bf484eee..309878d74f5a8c13ce3c45cd0c073c4a46d0b5dc 100644
--- a/container/hashmap/js_hashmap.ts
+++ b/container/hashmap/js_hashmap.ts
@@ -67,15 +67,12 @@ if (flag || fastHashMap === undefined) {
       return super.Values().indexOf(value) > -1;
     }
     get(key: K): V {
-      let result = super.getValueByKey(key);
-      if (result === undefined)
-        throw new Error("this hashmap don't find the key");
-      return result;
+      return this.getValueByKey(key);
     }
     setAll(map: HashMap<K, V>): void {
-      let memebers = this.keyValueArray;
+      let memebers = map.keyValueArray;
       for (let i = 0; i < memebers.length; i++) {
-        map.put(memebers[i].key, memebers[i].value);
+        this.put(memebers[i].key, memebers[i].value);
       }
     }
     set(key: K, value: V): Object {
@@ -83,7 +80,7 @@ if (flag || fastHashMap === undefined) {
     }
     remove(key: K): V {
       let result = this.removeMember(key);
-      if (result === null) {
+      if (result === undefined) {
         throw new Error("The removed element does not exist in this container");
       }
       return result;
@@ -97,7 +94,8 @@ if (flag || fastHashMap === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].key : undefined;
+          var value = !done ? data.keyValueArray[count].key : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -111,7 +109,8 @@ if (flag || fastHashMap === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].value : undefined;
+          var value = !done ? data.keyValueArray[count].value : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -135,7 +134,8 @@ if (flag || fastHashMap === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].entry() : undefined;
+          var value = !done ? data.keyValueArray[count].entry() : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -149,7 +149,8 @@ if (flag || fastHashMap === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].entry() : undefined;
+          var value = !done ? data.keyValueArray[count].entry() : undefined;
+          count++;
           return {
             done: done,
             value: value,
diff --git a/container/hashset/js_hashset.ts b/container/hashset/js_hashset.ts
index 4438a656d32ecaf87fcfd6fd86bd1453df650ea9..a7def21a71a7ef8523bdf8f12883f07481f0e7eb 100644
--- a/container/hashset/js_hashset.ts
+++ b/container/hashset/js_hashset.ts
@@ -62,14 +62,14 @@ if (flag || fastHashSet === undefined) {
       return this.memberNumber === 0;
     }
     has(value: T): boolean {
-      return super.hasKey(value);
+      return this.hasKey(value);
     }
     add(value: T): boolean {
       if (this.has(value)) return false;
       return this.put(value);
     }
     remove(value: T): boolean {
-      if (this.removeMember(value) !== null) return true;
+      if (this.removeMember(value) !== undefined) return true;
       return false;
     }
     clear(): void {
@@ -88,7 +88,8 @@ if (flag || fastHashSet === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].key : undefined;
+          var value = !done ? data.keyValueArray[count].key : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -102,7 +103,8 @@ if (flag || fastHashSet === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].entry() : undefined;
+          var value = !done ? data.keyValueArray[count].entry() : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -116,7 +118,8 @@ if (flag || fastHashSet === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].key : undefined;
+          var value = !done ? data.keyValueArray[count].key : undefined;
+          count++;
           return {
             done: done,
             value: value,
diff --git a/container/lightweightmap/js_lightweightmap.ts b/container/lightweightmap/js_lightweightmap.ts
index 7c429b5c0c0107106ba1e7d30a1e1426d7a5fd80..e9e2e3428d3d7ad85dc7604151321642a9921205 100644
--- a/container/lightweightmap/js_lightweightmap.ts
+++ b/container/lightweightmap/js_lightweightmap.ts
@@ -59,8 +59,7 @@ if (flag || fastLightWeightMap === undefined) {
     }
     hasAll(map: LightWeightMap<K, V>): boolean {
       if (map.memberNumber > this.memberNumber) return false;
-      if (LightWeightAbility.isIncludeToArray(this.members.keys, map.members.keys) &&
-          LightWeightAbility.isIncludeToArray(this.members.values, map.members.values)) {
+      if (LightWeightAbility.isIncludeToArray(this.keyValueStringArray(), map.keyValueStringArray()) ) {
         return true;
       }
       return false;
@@ -121,14 +120,14 @@ if (flag || fastLightWeightMap === undefined) {
       };
     }
     setAll(map: LightWeightMap<K, V>): void {
-      if (map.memberNumber === 0) {
-        map.members.hashs = this.members.hashs.slice();
-        map.members.keys = this.members.keys.slice();
-        map.members.values = this.members.values.slice();
-        map.memberNumber = this.memberNumber;
+      if (this.memberNumber === 0) {
+        this.members.hashs = map.members.hashs.slice();
+        this.members.keys = map.members.keys.slice();
+        this.members.values = map.members.values.slice();
+        this.memberNumber = map.memberNumber;
       } else {
-        for (let i = 0; i < this.memberNumber; i++) {
-          map.addmember(this.members.keys[i], this.members.values[i]);
+        for (let i = 0; i < map.memberNumber; i++) {
+          this.addmember(map.members.keys[i], map.members.values[i]);
         }
       }
     }
@@ -191,7 +190,7 @@ if (flag || fastLightWeightMap === undefined) {
       return result.join(",");
     }
     getValueAt(index: number): V {
-      return this.members.values[index] as V;
+      return this.members.values[index];
     }
     values(): IterableIterator<V> {
       let data = this;
diff --git a/container/lightweightset/js_lightweightset.ts b/container/lightweightset/js_lightweightset.ts
index d4cbe7826e5661a64e4ac438c4388be8d5ab09ca..7e52388dcf2614d840d7eff5ed2172d85f58536b 100644
--- a/container/lightweightset/js_lightweightset.ts
+++ b/container/lightweightset/js_lightweightset.ts
@@ -65,17 +65,12 @@ if (flag || fastLightWeightSet === undefined) {
     addAll(set: LightWeightSet<T>): boolean {
       let change = false;
       if (set.memberNumber == 0) {
-        set.memberNumber = this.memberNumber;
-        set.members.hashs = this.members.hashs.slice();
-        set.members.keys = this.members.keys.slice();
-        set.members.values = this.members.values.slice();
-        set.memberNumber = this.memberNumber;
-        change = true;
+        change = false;
       } else {
-        for (let i = 0; i < this.memberNumber; i++) {
-          change = set.add(this.members.keys[i]) || change;
+        for (let i = 0; i < set.memberNumber; i++) {
+          change = this.add(set.members.keys[i]) || change;
         }
-      }
+      } 
       return change;
     }
     hasAll(set: LightWeightSet<T>): boolean {
@@ -90,7 +85,7 @@ if (flag || fastLightWeightSet === undefined) {
     }
     equal(obj: Object): boolean {
       if (this.memberNumber === 0) return false;
-      if (obj.toString() === this.members.keys.toString()) return true;
+      if (JSON.stringify(obj) === JSON.stringify(this.members.keys)) return true;
       return false;
     }
     increaseCapacityTo(minimumCapacity: number): void {
@@ -136,6 +131,7 @@ if (flag || fastLightWeightSet === undefined) {
         next: function () {
           var done = count >= data.memberNumber;
           var value = !done ? data.members.keys[count] : undefined;
+          count++;
           return {
             done: done,
             value: value,
diff --git a/container/linkedlist/js_linkedlist.ts b/container/linkedlist/js_linkedlist.ts
index fc78beae873f310b22693872797af3b6a92393ba..f8889c8e400885fb92f7892389cafd110fc61da1 100644
--- a/container/linkedlist/js_linkedlist.ts
+++ b/container/linkedlist/js_linkedlist.ts
@@ -32,6 +32,7 @@ if (flag || fastLinkedList == undefined) {
         if (index < 0 || index >= length) {
           throw new Error("LinkedList: get out-of-bounds");
         }
+        return obj.get(index);
       }
       return obj[prop];
     }
@@ -44,14 +45,13 @@ if (flag || fastLinkedList == undefined) {
         obj[prop] = value;
         return true;
       }
-
       var index = Number.parseInt(prop);
       if (Number.isInteger(index)) {
         let length = obj.length;
         if (index < 0 || index >= length) {
           throw new Error("LinkedList: set out-of-bounds");
         } else {
-          obj[index] = value;
+          obj.set(index, value);
           return true;
         }
       }
@@ -254,6 +254,9 @@ if (flag || fastLinkedList == undefined) {
       return -1;
     }
     removeByIndex(index: number): T {
+      if (index < 0 || index >= this._length) {
+        throw new Error("removeByIndex is out-of-bounds");
+      }
       let current = this._head;
       if (index === 0) {
         this._head = current && current.next;
@@ -276,6 +279,9 @@ if (flag || fastLinkedList == undefined) {
       return current && current.element;
     }
     remove(element: T): boolean {
+      if(this.isEmpty()){
+        return false;
+      }
       if (this.has(element)) {
         let index = this.getIndexOf(element);
         this.removeByIndex(index);
@@ -368,6 +374,9 @@ if (flag || fastLinkedList == undefined) {
       }
       return clone;
     }
+    private isEmpty(): boolean {
+      return this._length == 0;
+    }
     forEach(callbackfn: (value: T,index?: number,linkedlist?: LinkedList<T>) => void,
       thisArg?: Object): void {
       let index = 0;
@@ -382,7 +391,7 @@ if (flag || fastLinkedList == undefined) {
     }
     [Symbol.iterator](): IterableIterator<T> {
       let count = 0;
-      let linkedlist = this
+      let linkedlist = this;
       return {
         next: function () {
           var done = count >= linkedlist._length;
diff --git a/container/list/js_list.ts b/container/list/js_list.ts
index 192526a6e7d95a02adfb0a3989488c39bc4e30a7..1c6b225c2ad7a26f04155a5c59a79bb03128edf7 100644
--- a/container/list/js_list.ts
+++ b/container/list/js_list.ts
@@ -31,6 +31,7 @@ if (flag || fastList == undefined) {
         if (index < 0 || index >= obj.length) {
           throw new Error("List: get out-of-bounds");
         }
+        return obj.get(index);
       }
       return obj[prop];
     }
@@ -48,7 +49,7 @@ if (flag || fastList == undefined) {
         if (index < 0 || index >= obj.length) {
           throw new Error("List: set out-of-bounds");
         } else {
-          obj[index] = value;
+          obj.set(index, value);
           return true;
         }
       }
@@ -222,6 +223,9 @@ if (flag || fastList == undefined) {
       return -1;
     }
     removeByIndex(index: number): T {
+      if (index < 0 || index >= this._length) {
+        throw new Error("removeByIndex is out-of-bounds");
+      }
       let oldNode = this._head;
       if (index === 0) {
         oldNode = this._head;
@@ -305,6 +309,9 @@ if (flag || fastList == undefined) {
       if (toIndex <= fromIndex) {
         throw new Error("toIndex cannot be less than or equal to fromIndex");
       }
+      if (fromIndex >= this._length || fromIndex < 0 || toIndex < 0) {
+        throw new Error(`fromIndex or toIndex is out-of-bounds`);
+      }
       toIndex = toIndex > this._length ? this._length - 1 : toIndex;
       let list = new List<T>();
       for (let i = fromIndex; i < toIndex; i++) {
@@ -348,7 +355,7 @@ if (flag || fastList == undefined) {
     }
     [Symbol.iterator](): IterableIterator<T> {
       let count = 0;
-      let list = this
+      let list = this;
       return {
         next: function () {
           var done = count >= list._length;
diff --git a/container/plainarray/js_plainarray.ts b/container/plainarray/js_plainarray.ts
index ff3a5dd9de2f887eab346eac5bf1fce1b6ce2fdd..f1855af85ac790cef9a92f7a77281bbfd75a2c69 100644
--- a/container/plainarray/js_plainarray.ts
+++ b/container/plainarray/js_plainarray.ts
@@ -82,7 +82,6 @@ if (flag || fastPlainArray === undefined) {
     }
     get(key: number): T {
       let index = this.binarySearchAtPlain(key);
-      if (index < 0) throw new Error("Key error found");
       return this.members.values[index];
     }
     getIndexOfKey(key: number): number {
@@ -100,7 +99,7 @@ if (flag || fastPlainArray === undefined) {
     }
     remove(key: number): T {
       let index = this.binarySearchAtPlain(key);
-      if (index < 0) throw new Error(" element not in this plainarray");
+      if (index < 0) throw new Error("element not in this plainarray");
       return this.deletemember(index);
     }
     removeAt(index: number): T {
@@ -109,7 +108,7 @@ if (flag || fastPlainArray === undefined) {
     }
     removeRangeFrom(index: number, size: number): number {
       if (index >= this.memberNumber || index < 0) throw new Error("index not in this plainarray range");
-      let safeSize = (this.memberNumber - (index + size) < 0) ? this.memberNumber - size : size;
+      let safeSize = (this.memberNumber - (index + size) < 0) ? this.memberNumber - index : size;
       this.deletemember(index, safeSize);
       return safeSize;
     }
diff --git a/container/struct/js_struct.ts b/container/struct/js_struct.ts
index 3a7cd15f530333a82e289df2a72e840742b0bcab..722e6c110a0d483037f078e17445b6c2e1f06f73 100644
--- a/container/struct/js_struct.ts
+++ b/container/struct/js_struct.ts
@@ -58,6 +58,9 @@ function compareToString(string1: String, string2: String) {
 
 function currencyCompare(a: any, b: any, compareFn?: Function): number {
   if (a === b) return ComparResult.EQUALS;
+  if (a instanceof Pair && b instanceof Pair) {
+    return currencyCompare(a.key, b.key, compareFn);
+  }
   if (compareFn != undefined) {
     return compareFn(a, b) ? ComparResult.BIGGER_THAN : ComparResult.LESS_THAN;
   }
@@ -73,8 +76,6 @@ function currencyCompare(a: any, b: any, compareFn?: Function): number {
     return ComparResult.BIGGER_THAN;
   } else if (typeof a === "number" && typeof b === "string") {
     return ComparResult.LESS_THAN;
-  } else if (a instanceof Pair && b instanceof Pair) {
-    return currencyCompare(a.key, b.key);
   }
   throw new Error("This form of comparison is not supported");
 }
@@ -122,7 +123,7 @@ class PlainArrayClass<T> {
 
   protected addmember(key: number, value: T) {
     let index = this.binarySearchAtPlain(key);
-    if (index > 0) {
+    if (index >= 0) {
       this.members.keys[index] = key;
       this.members.values[index] = value;
     } else {
@@ -181,7 +182,7 @@ class LightWeightClass<K, V> {
   protected addmember(key: K, value: V = key as unknown as V) {
     let hash = hashCode(key);
     let index = this.binarySearchAtLightWeight(hash);
-    if (index > 0) {
+    if (index >= 0) {
       this.members.keys[index] = key;
       this.members.values[index] = value;
     } else {
@@ -225,10 +226,10 @@ class LightWeightClass<K, V> {
     return index;
   }
 
-  protected keyArray(): Array<K> {
-    let resultArray: Array<K> = [];
+  protected keyValueStringArray(): Array<string> {
+    let resultArray: Array<string> = [];
     for (let i = 0; i < this.memberNumber; i++) {
-      resultArray.push(this.members[i].key);
+      resultArray.push(JSON.stringify(this.members.keys[i]) + ":" + JSON.stringify(this.members.values[i]));
     }
     return resultArray;
   }
@@ -252,20 +253,20 @@ class LightWeightClass<K, V> {
   }
 }
 
-type RBTreeNodeColor = "black" | "red";
-const BLACK = "black";
-const RED = "red";
+type RBTreeNodeColor = 0 | 1;
+const BLACK = 0;
+const RED = 1;
 class RBTreeNode<K, V> extends Pair<K, V>{
   color: RBTreeNodeColor;
-  left: RBTreeNode<K, V> | null;
-  right: RBTreeNode<K, V> | null;
-  parent: RBTreeNode<K, V> | null;
+  left: RBTreeNode<K, V> | undefined;
+  right: RBTreeNode<K, V> | undefined;
+  parent: RBTreeNode<K, V> | undefined;
   constructor(key: K,
     value?: V,
     color: RBTreeNodeColor = RED,
-    parent: RBTreeNode<K, V> | null = null,
-    left: RBTreeNode<K, V> | null = null,
-    right: RBTreeNode<K, V> | null = null) {
+    parent?: RBTreeNode<K, V>,
+    left?: RBTreeNode<K, V>,
+    right?: RBTreeNode<K, V>) {
     super(key, value);
     this.color = color;
     this.left = left;
@@ -274,12 +275,14 @@ class RBTreeNode<K, V> extends Pair<K, V>{
   }
 }
 class RBTreeClass<K, V> {
-  private _root: RBTreeNode<K, V> | null;
+  private _root: RBTreeNode<K, V> | undefined;
   public memberNumber: number;
   private _isChange: boolean;
   private _treeArray: Array<RBTreeNode<K, V>>;
-  constructor(root: RBTreeNode<K, V> | null = null) {
+  private _compFun: Function | undefined;
+  constructor(comparator?: (firstValue: K, secondValue: K) => boolean, root?: RBTreeNode<K, V>) {
     this._root = root;
+    this._compFun = comparator;
     this.memberNumber = 0;
     this._isChange = true;
     this._treeArray = [];
@@ -291,9 +294,9 @@ class RBTreeClass<K, V> {
   }
 
   addNode(key: K, value: V = key as unknown as V): RBTreeClass<K, V> {
-    if (this._root === null) {
-      this._root = new RBTreeNode<K, V>(key, value)
-      this.setColor(this._root, BLACK);
+    if (this._root === undefined) {
+      this._root = new RBTreeNode<K, V>(key, value);
+      this.setColor(BLACK, this._root);
       this.memberNumber++;
       this._isChange = true;
     } else {
@@ -303,12 +306,12 @@ class RBTreeClass<K, V> {
   }
 
   addProcess(key: K, value: V): RBTreeClass<K, V> {
-    let leafNode: RBTreeNode<K, V> | null = this._root;
+    let leafNode: RBTreeNode<K, V> | undefined = this._root;
     let parentNode: RBTreeNode<K, V> = this._root as RBTreeNode<K, V>;
     let comp: number = 0;
-    while (leafNode !== null) {
+    while (leafNode !== undefined) {
       parentNode = leafNode;
-      comp = currencyCompare(leafNode.key, key);
+      comp = currencyCompare(leafNode.key, key, this._compFun);
       if (comp === 0) {
         leafNode.value = value;
         return this;
@@ -331,10 +334,10 @@ class RBTreeClass<K, V> {
     return this;
   }
 
-  removeNode(key: K): V | null {
+  removeNode(key: K): V | undefined {
     const removeNode = this.getNode(key);
-    if (removeNode === null) {
-      return null;
+    if (removeNode === undefined) {
+      return undefined;
     } else {
       let result = removeNode.value;
       this.removeNodeProcess(removeNode);
@@ -343,92 +346,104 @@ class RBTreeClass<K, V> {
   }
 
   removeNodeProcess(removeNode: RBTreeNode<K, V>) {
-    if (removeNode.left !== null && removeNode.right !== null) {
+    if (removeNode.left !== undefined && removeNode.right !== undefined) {
       let successor = removeNode.right;
-      while (successor.left !== null) {
+      while (successor.left !== undefined) {
         successor = successor.left;
       }
-      removeNode = successor;
-    }
-    let replacementNode = (removeNode.right === null ? removeNode.left : removeNode.right);
-    if (replacementNode !== null) {
-      replacementNode.parent = removeNode.parent;
-      if (removeNode.parent === null) {
-        this._root = replacementNode;
-      } else if (removeNode === removeNode.parent.right) {
-        removeNode.parent.right = replacementNode;
-      } else if (removeNode === removeNode.parent.left) {
-        removeNode.parent.left = replacementNode;
-      }
-      if (this.getColor(removeNode) === BLACK) {
-        this.deleteRebalance(replacementNode)
-      }
-    } else if (removeNode.parent === null) {
-      // removeNode.right = null; removeNode.left = null
-      this._root = null;
-    } else {
-      if (this.getColor(removeNode) === BLACK) {
-        this.deleteRebalance(removeNode)
-      }
-      if (removeNode === removeNode.parent.left) {
-        removeNode.parent.left = null;
-      } else if (removeNode === removeNode.parent.right) {
-        removeNode.parent.right = null;
+      removeNode.key = successor.key;
+      removeNode.value = successor.value;
+      this.removeNodeProcess(successor); // only once
+      return;
+    } else {  // one or zero child
+      let child = (removeNode.left === undefined ? removeNode.right : removeNode.left);
+      if (removeNode.parent === undefined) { // remove is root
+        if (child === undefined) {
+          this._root = undefined;
+        } else {
+          child.parent = undefined;
+          child.color = BLACK;
+          this._root = child;
+        }
+      } else {
+        if (child != undefined) {
+          // delete removeNode
+          if (removeNode.parent.left === removeNode) {
+            removeNode.parent.left = child;
+          } else {
+            removeNode.parent.right = child;
+          }
+          if (this.getColor(removeNode) === BLACK) {
+            this.deleteRebalance(child)
+          }
+        } else {
+          if (this.getColor(removeNode) === BLACK) {
+            this.deleteRebalance(removeNode)
+          }
+          if (removeNode.parent.left === removeNode) {
+            removeNode.parent.left = child;
+          } else {
+            removeNode.parent.right = child;
+          }
+        }
       }
+      this.memberNumber--;
+      this._isChange = true;
     }
-    this.memberNumber--;
-    this._isChange = true;
   }
 
-  getNode(key: K): RBTreeNode<K, V> | null {
-    if (this._root === null)
-      return null;
-    let removeNode: RBTreeNode<K, V> | null = this._root;
-    while (removeNode !== null && removeNode.key !== key) {
-      removeNode = removeNode.key > key ? removeNode.left : removeNode.right;
+  getNode(key: K): RBTreeNode<K, V> | undefined {
+    if (this._root === undefined)
+      return undefined;
+    let findNode: RBTreeNode<K, V> | undefined = this._root;
+    while (findNode !== undefined && findNode.key !== key) {
+      findNode = currencyCompare(findNode.key, key, this._compFun) === ComparResult.BIGGER_THAN ? 
+	      	findNode.left : findNode.right;
     }
-    return removeNode;
+    return findNode;
   }
 
-  findNode(value: V): RBTreeNode<K, V> | null {
-    let tempNode: RBTreeNode<K, V> | null = null;
+  findNode(value: V): RBTreeNode<K, V> | undefined {
+    let tempNode: RBTreeNode<K, V> | undefined = undefined;
     this.recordByMinToMax();
     for (let i = 0; i < this.memberNumber; i++) {
-      if (this._treeArray[i].value === value) tempNode = this._treeArray[i];
-      break;
+      if (this._treeArray[i].value === value) {
+        tempNode = this._treeArray[i];
+        break;
+      }
     }
     return tempNode;
   }
 
-  firstNode(): RBTreeNode<K, V> | null {
-    let tempNode: RBTreeNode<K, V> | null = this._root;
-    while (tempNode !== null && tempNode.left !== null) {
+  firstNode(): RBTreeNode<K, V> | undefined {
+    let tempNode: RBTreeNode<K, V> | undefined = this._root;
+    while (tempNode !== undefined && tempNode.left !== undefined) {
       tempNode = tempNode.left;
     }
     return tempNode;
   }
 
-  lastNode(): RBTreeNode<K, V> | null {
-    let tempNode: RBTreeNode<K, V> | null = this._root;
-    while (tempNode !== null && tempNode.right !== null) {
+  lastNode(): RBTreeNode<K, V> | undefined {
+    let tempNode: RBTreeNode<K, V> | undefined = this._root;
+    while (tempNode !== undefined && tempNode.right !== undefined) {
       tempNode = tempNode.right;
     }
     return tempNode;
   }
 
   isEmpty(): boolean {
-    return this._root === null;
+    return this._root === undefined;
   }
 
   setAll(map: RBTreeClass<K, V>) {
-    this.recordByMinToMax();
-    for (let i = 0; i < this.memberNumber; i++) {
-      map.addNode(this._treeArray[i].key, this._treeArray[i].value);
+    let tempArray = map.recordByMinToMax();
+    for (let i = 0; i < map.memberNumber; i++) {
+      this.addNode(tempArray[i].key, tempArray[i].value);
     }
   }
 
   clearTree() {
-    this._root = null;
+    this._root = undefined;
     this.memberNumber = 0;
   }
 
@@ -437,13 +452,13 @@ class RBTreeClass<K, V> {
     let stack = [];
     this._treeArray = [];
     let node = this._root;
-    while (node != null || stack.length) {
-      while (node != null) {
+    while (node != undefined || stack.length) {
+      while (node != undefined) {
         stack.push(node);
         node = node.left;
       }
       let tempNode = stack.pop();
-      if (tempNode === undefined || tempNode === null)
+      if (tempNode === undefined || tempNode === undefined)
         throw new Error("this function run error");
       node = tempNode;
       this._treeArray.push(node);
@@ -456,12 +471,12 @@ class RBTreeClass<K, V> {
 
   private lRotate(datumPointNode: RBTreeNode<K, V>): RBTreeClass<K, V> {
     let newTopNode = datumPointNode.right;
-    if (newTopNode === null)
-      throw new Error("[rotate right error]: the right child node of the base node === null")
+    if (newTopNode === undefined)
+      throw new Error("[rotate right error]: the right child node of the base node === undefined")
     datumPointNode.right = newTopNode.left;
-    datumPointNode.right !== null ? datumPointNode.right.parent = datumPointNode : "";
+    datumPointNode.right !== undefined ? datumPointNode.right.parent = datumPointNode : "";
     newTopNode.parent = datumPointNode.parent;
-    if (datumPointNode.parent === null) {
+    if (datumPointNode.parent === undefined) {
       this._root = newTopNode;
     } else if (datumPointNode.parent.left === datumPointNode) {
       datumPointNode.parent.left = newTopNode;
@@ -475,13 +490,13 @@ class RBTreeClass<K, V> {
 
   private rRotate(datumPointNode: RBTreeNode<K, V>): RBTreeClass<K, V> {
     const newTopNode = datumPointNode.left;
-    if (newTopNode === null) {
-      throw new Error("[rotate right error]: the left child node of the base node === null")
+    if (newTopNode === undefined) {
+      throw new Error("[rotate right error]: the left child node of the base node === undefined")
     }
     datumPointNode.left = newTopNode.right;
-    datumPointNode.left !== null ? datumPointNode.left.parent = datumPointNode : "";
+    datumPointNode.left !== undefined ? datumPointNode.left.parent = datumPointNode : "";
     newTopNode.parent = datumPointNode.parent
-    if (datumPointNode.parent === null) {
+    if (datumPointNode.parent === undefined) {
       this._root = newTopNode;
     } else if (datumPointNode === datumPointNode.parent.left) {
       datumPointNode.parent.left = newTopNode;
@@ -496,23 +511,23 @@ class RBTreeClass<K, V> {
   private insertRebalance(fixNode: RBTreeNode<K, V>): RBTreeClass<K, V> {
     let parentNode = fixNode.parent;
     while (this.getColor(parentNode) === RED &&
-      parentNode !== null &&
-      parentNode.parent !== null) {
+      parentNode !== undefined &&
+      parentNode.parent !== undefined) {
       let grandpaNode = parentNode && parentNode.parent;
       if (parentNode === grandpaNode.left &&
         this.getColor(grandpaNode.right) === BLACK &&
         fixNode === parentNode.left) {
         this
-          .setColor(parentNode, BLACK)
-          .setColor(grandpaNode, RED)
+          .setColor(BLACK, parentNode)
+          .setColor(RED, grandpaNode)
           .rRotate(grandpaNode)
         break;
       } else if (parentNode === grandpaNode.left &&
         this.getColor(grandpaNode.right) === BLACK &&
         fixNode === parentNode.right) {
         this
-          .setColor(fixNode, BLACK)
-          .setColor(grandpaNode, RED)
+          .setColor(BLACK, fixNode)
+          .setColor(RED, grandpaNode)
           .lRotate(parentNode)
           .rRotate(grandpaNode)
         break;
@@ -520,8 +535,8 @@ class RBTreeClass<K, V> {
         this.getColor(grandpaNode.left) === BLACK &&
         fixNode === parentNode.left) {
         this
-          .setColor(fixNode, BLACK)
-          .setColor(grandpaNode, RED)
+          .setColor(BLACK, fixNode)
+          .setColor(RED, grandpaNode)
           .rRotate(parentNode)
           .lRotate(grandpaNode)
         break;
@@ -529,16 +544,16 @@ class RBTreeClass<K, V> {
         this.getColor(grandpaNode.left) === BLACK &&
         fixNode === parentNode.right) {
         this
-          .setColor(parentNode, BLACK)
-          .setColor(grandpaNode, RED)
+          .setColor(BLACK, parentNode)
+          .setColor(RED, grandpaNode)
           .lRotate(grandpaNode)
         break;
       } else if ((parentNode === grandpaNode.right && this.getColor(grandpaNode.left) === RED) ||
         (parentNode === grandpaNode.left && this.getColor(grandpaNode.right) === RED)) {
         this
-          .setColor(parentNode, BLACK)
-          .setColor(parentNode === grandpaNode.left ? grandpaNode.right : grandpaNode.left, BLACK)
-          .setColor(grandpaNode, RED)
+          .setColor(BLACK, parentNode)
+          .setColor(BLACK, parentNode === grandpaNode.left ? grandpaNode.right : grandpaNode.left)
+          .setColor(RED, grandpaNode)
         fixNode = grandpaNode;
         parentNode = fixNode.parent;
       } else {
@@ -551,42 +566,42 @@ class RBTreeClass<K, V> {
 
   private deleteRebalance(fixNode: RBTreeNode<K, V>) {
     while (this.getColor(fixNode) === BLACK && fixNode !== this._root && fixNode.parent) {
-      let sibling: RBTreeNode<K, V> | null;
+      let sibling: RBTreeNode<K, V> | undefined;
       if (fixNode === fixNode.parent.left) {
         sibling = fixNode.parent.right;
         if (this.getColor(sibling) === RED) {
           this
-            .setColor(fixNode.parent, RED)
-            .setColor(sibling, BLACK)
+            .setColor(RED, fixNode.parent)
+            .setColor(BLACK, sibling)
             .lRotate(fixNode.parent)
           sibling = fixNode.parent.right;
         }
-        if (sibling === null) {
-          throw new Error('Error sibling node is null')
+        if (sibling === undefined) {
+          throw new Error('Error sibling node is undefined')
         }
         if (this.getColor(sibling.left) === BLACK && this.getColor(sibling.right) === BLACK) {
-          this.setColor(sibling, RED)
+          this.setColor(RED, sibling)
           fixNode = fixNode.parent
         } else if (this.getColor(sibling.left) === RED && this.getColor(sibling.right) === BLACK) {
           this
-            .setColor(sibling, RED)
-            .setColor(sibling.left, BLACK)
+            .setColor(RED, sibling)
+            .setColor(BLACK, sibling.left)
             .rRotate(sibling);
           sibling = fixNode.parent.right
-          if (sibling === null) {
+          if (sibling === undefined) {
             throw new Error('Error sibling node is empty')
           }
           this
-            .setColor(sibling, fixNode.parent.color)
-            .setColor(fixNode.parent, BLACK)
-            .setColor(sibling.right, BLACK)
+            .setColor(fixNode.parent.color, sibling)
+            .setColor(BLACK, fixNode.parent)
+            .setColor(BLACK, sibling.right)
             .lRotate(fixNode.parent);
           break;
         } else if (this.getColor(sibling.right) === RED) {
           this
-            .setColor(sibling, fixNode.parent.color)
-            .setColor(fixNode.parent, BLACK)
-            .setColor(sibling.right, BLACK)
+            .setColor(fixNode.parent.color, sibling)
+            .setColor(BLACK, fixNode.parent)
+            .setColor(BLACK, sibling.right)
             .lRotate(fixNode.parent);
           break;
         } else {
@@ -596,38 +611,38 @@ class RBTreeClass<K, V> {
         sibling = fixNode.parent.left;
         if (this.getColor(sibling) === RED) {
           this
-            .setColor(sibling, BLACK)
-            .setColor(fixNode.parent, RED)
+            .setColor(BLACK, sibling)
+            .setColor(RED, fixNode.parent)
             .rRotate(fixNode.parent);
           sibling = fixNode.parent.left;
         }
-        if (sibling === null) {
-          throw new Error('Error sibling node is null')
+        if (sibling === undefined) {
+          throw new Error('Error sibling node is undefined')
         }
         if (this.getColor(sibling.left) === BLACK && this.getColor(sibling.right) === BLACK) {
           this
-            .setColor(sibling, RED)
+            .setColor(RED, sibling)
           fixNode = fixNode.parent;
         } else if (this.getColor(sibling.left) === BLACK && this.getColor(sibling.right) === RED) {
           this
-            .setColor(sibling, RED)
-            .setColor(sibling.right, BLACK)
+            .setColor(RED, sibling)
+            .setColor(BLACK, sibling.right)
             .lRotate(sibling);
           sibling = fixNode.parent.left;
-          if (sibling === null) {
+          if (sibling === undefined) {
             throw new Error('Adjust the error after the error is deleted')
           }
           this
-            .setColor(sibling, fixNode.parent.color)
-            .setColor(fixNode.parent, BLACK)
-            .setColor(sibling.left, BLACK)
+            .setColor(fixNode.parent.color, sibling)
+            .setColor(BLACK, fixNode.parent)
+            .setColor(BLACK, sibling.left)
             .rRotate(fixNode.parent);
           break;
         } else if (this.getColor(sibling.left) === RED) {
           this
-            .setColor(sibling, fixNode.parent.color)
-            .setColor(fixNode.parent, BLACK)
-            .setColor(sibling.left, BLACK)
+            .setColor(fixNode.parent.color, sibling)
+            .setColor(BLACK, fixNode.parent,)
+            .setColor(BLACK, sibling.left)
             .rRotate(fixNode.parent);
           break;
         } else {
@@ -635,15 +650,15 @@ class RBTreeClass<K, V> {
         }
       }
     }
-    this.setColor(fixNode, BLACK)
+    this.setColor(BLACK, fixNode)
   }
 
-  private getColor(node: RBTreeNode<K, V> | null): RBTreeNodeColor {
-    return node === null ? BLACK : node.color;
+  private getColor(node: RBTreeNode<K, V> | undefined): RBTreeNodeColor {
+    return node === undefined ? BLACK : node.color;
   }
 
-  private setColor(node: RBTreeNode<K, V> | null, color: RBTreeNodeColor): RBTreeClass<K, V> {
-    if (node === null) {
+  private setColor(color: RBTreeNodeColor, node: RBTreeNode<K, V> | undefined): RBTreeClass<K, V> {
+    if (node === undefined) {
       throw new Error("Wrong color setting")
     } else {
       node.color = color
@@ -676,7 +691,16 @@ class DictionaryClass<K, V>  {
   protected getHashIndex(key: K): number {
     let h;
     let hash = ((key === null) ? 0 : ((h = hashCode(key)) ^ (h >>> 16)));
-    this.expandCapacity();
+    if (this.expandCapacity()) {
+      this.keyValues();
+      this.memberNumber = 0;
+      this._tableLink = {};
+      this._isChange = true;
+      for (let item of this._memberArray) {
+        this.put(item.key, item.value);
+      }
+      this.memberNumber++;
+    }
     let n = this.power(this._capacity);
     return (n - 1) & hash;
   }
@@ -703,9 +727,9 @@ class DictionaryClass<K, V>  {
           this._memberArray.push(new Pair(tempArray[i].key, tempArray[i].value));
         }
       } else {
-        if (members != null && !members.isEmpty()) {
+        if (members != undefined && !members.isEmpty()) {
           let current = members.getHead();
-          while (current != null) {
+          while (current != undefined) {
             this._memberArray.push(current.element);
             current = current.next;
           }
@@ -718,15 +742,18 @@ class DictionaryClass<K, V>  {
   }
 
   protected expandCapacity() {
+    let capacityChange = false;
     while (this._capacity < this.memberNumber / LOADER_FACTOR && this._capacity < MAX_CAPACITY) {
       this._capacity = 2 * this._capacity;
+      capacityChange = true;
     }
+    return capacityChange;
   }
 
   protected put(key: K, value: V = key as unknown as V): boolean {
-    if (key != null && value != null) {
+    if (key != undefined && value != undefined) {
       this._isChange = true;
-      this.memberNumber++;
+      if (!this.hasKey(key)) this.memberNumber++;
       const position = this.getHashIndex(key);
       let members = this._tableLink[position];
       if (members instanceof LinkedList && members.count >= 8) {
@@ -746,7 +773,7 @@ class DictionaryClass<K, V>  {
         this._tableLink[position] = members;
         return true;
       } else {
-        if (this._tableLink[position] == null) {
+        if (this._tableLink[position] == undefined) {
           members = new LinkedList<Pair<K, V>>();
         }
         if (!this.replaceMember(key, value)) {
@@ -764,7 +791,7 @@ class DictionaryClass<K, V>  {
     const members = this._tableLink[position] as LinkedList<Pair<K, V>>;
     if (members === null || members === undefined) return false;
     let current = members.getHead();
-    while (current != null || current != undefined) {
+    while (current != undefined) {
       if (current.element.key === key) {
         current.element.value = value;
         return true;
@@ -779,13 +806,13 @@ class DictionaryClass<K, V>  {
     const members = this._tableLink[position];
     if (members instanceof RBTreeClass) {
       let resultNode = members.getNode(key);
-      if (resultNode === null) return undefined;
+      if (resultNode === undefined) return undefined;
       return resultNode.value;
     } else {
-      if (members != null && !members.isEmpty()) {
+      if (members != undefined && !members.isEmpty()) {
         members as LinkedList<Pair<K, V>>;
         let current = members.getHead();
-        while (current != null) {
+        while (current != undefined) {
           if (current.element.key === key) {
             return current.element.value;
           }
@@ -796,20 +823,20 @@ class DictionaryClass<K, V>  {
     return undefined;
   }
 
-  protected removeMember(key: K): V | null {
+  protected removeMember(key: K): V | undefined {
     const position = this.getHashIndex(key);
     const members = this._tableLink[position];
     if (members instanceof RBTreeClass) {
       let result = members.removeNode(key);
-      if (result != null) {
+      if (result != undefined) {
         this._isChange = true;
         this.memberNumber--;
         return result;
       }
     } else {
-      if (members != null && !members.isEmpty()) {
+      if (members != undefined && !members.isEmpty()) {
         let current = members.getHead();
-        while (current != null) {
+        while (current != undefined) {
           if (current.element.key === key) {
             const result = current.element.value;
             members.remove(current.element);
@@ -824,24 +851,25 @@ class DictionaryClass<K, V>  {
         }
       }
     }
-    return null;
+    return undefined;
   }
 
   protected clear() {
     this._tableLink = {};
     this.memberNumber = 0;
     this._isChange = true;
+    this._capacity = 16;
   }
 
   protected hasKey(key: K): boolean {
     const position = this.getHashIndex(key);
     const members = this._tableLink[position];
-    if (members === null || members === undefined) return false;
+    if (members === undefined || members === undefined) return false;
     if (members instanceof RBTreeClass) {
-      return members.getNode(key) !== null;
+      return members.getNode(key) !== undefined;
     }
     let current = members.getHead();
-    while (current != null && current != undefined) {
+    while (current != undefined && current != undefined) {
       if (current.element.key === key) {
         return true;
       }
@@ -851,9 +879,9 @@ class DictionaryClass<K, V>  {
   }
 
   protected setAll(map: DictionaryClass<K, V>): void {
-    let memebers = this.keyValues();
+    let memebers = map.keyValues();
     for (let i = 0; i < memebers.length; i++) {
-      map.put(memebers[i].key, memebers[i].value);
+      this.put(memebers[i].key, memebers[i].value);
     }
   }
 
@@ -867,32 +895,32 @@ class DictionaryClass<K, V>  {
   }
 }
 
-class Node<T>{
+class Node<T> {
   element: T;
-  next: Node<T> | null;
-  constructor(element: T, next: Node<T> | null = null) {
+  next: Node<T> | undefined;
+  constructor(element: T, next?: Node<T>) {
     this.element = element;
     this.next = next;
   }
 }
 class LinkedList<T> {
   public count: number;
-  protected next: Node<T> | null;
-  protected head: Node<T> | null;
+  protected next: Node<T> | undefined;
+  protected head: Node<T> | undefined;
   constructor() {
     this.count = 0;
-    this.next = null;
-    this.head = null;
+    this.next = undefined;
+    this.head = undefined;
   }
 
   push(element: T) {
     const node = new Node(element);
     let current;
-    if (this.head == null) {
+    if (this.head == undefined) {
       this.head = node;
     } else {
       current = this.head;
-      while (current.next != null) {
+      while (current.next != undefined) {
         current = current.next;
       }
       current.next = node;
@@ -903,16 +931,16 @@ class LinkedList<T> {
   removeAt(index: number) {
     if (index >= 0 && index < this.count) {
       let current = this.head;
-      if (index === 0 && current != null) {
+      if (index === 0 && current != undefined) {
         this.head = current.next;
       } else {
         const previous = this.getElementAt(index--);
-        if (previous !== null) {
+        if (previous !== undefined) {
           current = previous.next;
-          previous.next = (current === null ? null : current.next);
+          previous.next = (current === undefined ? undefined : current.next);
         }
       }
-      if (current !== null) {
+      if (current !== undefined) {
         this.count--;
         return current.element;
       }
@@ -923,12 +951,12 @@ class LinkedList<T> {
   getElementAt(index: number) {
     if (index > 0 && index < this.count) {
       let current = this.head;
-      for (let i = 0; i < index && current != null; i++) {
+      for (let i = 0; i < index && current != undefined; i++) {
         current = current.next;
       }
       return current;
     }
-    return null;
+    return undefined;
   }
 
   insert(element: T, index: number) {
@@ -939,7 +967,7 @@ class LinkedList<T> {
         this.head = node;
       } else {
         const previous = this.getElementAt(index--);
-        if (previous === null)
+        if (previous === undefined)
           throw new Error("data storage error");
         node.next = previous.next;
         previous.next = node;
@@ -950,10 +978,10 @@ class LinkedList<T> {
     return false;
   }
 
-  indexOf(element: T) {
+  indexOf(element: T, compareFn?: Function) {
     let current = this.head;
-    for (let i = 0; i < this.count && current != null; i++) {
-      if (currencyCompare(element, current.element)) {
+    for (let i = 0; i < this.count && current != undefined; i++) {
+      if (currencyCompare(element, current.element, compareFn) === ComparResult.EQUALS) {
         return i;
       }
       current = current.next;
@@ -961,12 +989,12 @@ class LinkedList<T> {
     return -1;
   }
 
-  remove(element: T) {
-    this.removeAt(this.indexOf(element));
+  remove(element: T, compareFn?: Function) {
+    this.removeAt(this.indexOf(element, compareFn));
   }
 
   clear() {
-    this.head = null;
+    this.head = undefined;
     this.count = 0;
   }
 
@@ -979,12 +1007,12 @@ class LinkedList<T> {
   }
 
   toString() {
-    if (this.head == null) {
+    if (this.head == undefined) {
       return "";
     }
     let objString = `${this.head.element}`;
     let current = this.head.next;
-    for (let i = 1; i < this.count && current != null; i++) {
+    for (let i = 1; i < this.count && current != undefined; i++) {
       objString = `${objString}, ${current.element}`;
       current = current.next;
     }
diff --git a/container/treemap/js_treemap.ts b/container/treemap/js_treemap.ts
index 0b14f90b777d1d1ff04c278070c7a57cb5c37451..2fe6b7940ed0a3c86b6f41d41cdac91bece291c4 100644
--- a/container/treemap/js_treemap.ts
+++ b/container/treemap/js_treemap.ts
@@ -51,35 +51,38 @@ if (flag || fastTreeMap === undefined) {
   }
   class TreeMap<K, V> {
     private _constitute: any;
-    constructor() {
-      this._constitute = new RBTreeAbility.RBTreeClass();
+    constructor(comparator?: (firstValue: K, secondValue: K) => boolean) {
+      this._constitute = new RBTreeAbility.RBTreeClass(comparator);
       return new Proxy(this, new HandlerTreeMap());
-    } 
+    }
     get length() {
       return this._constitute.memberNumber;
     }
+    isEmpty() {
+      return this._constitute.memberNumber === 0;
+    }
     hasKey(key: K): boolean {
-      return this._constitute.getNode(key) !== null;
+      return this._constitute.getNode(key) !== undefined;
     }
     hasValue(value: V): boolean {
-      return this._constitute.findNode(value) !== null;
+      return this._constitute.findNode(value) !== undefined;
     }
-    get(key: K): V | null {
+    get(key: K): V {
       let tempNode = this._constitute.getNode(key);
-      if (tempNode === null)
-        return null;
+      if (tempNode === undefined)
+        throw new Error("The node of this key does not exist in the tree");
       return tempNode.value;
     }
     getFirstKey(): K {
       let tempNode = this._constitute.firstNode();
-      if (tempNode === null)
-        throw new Error("don't find this key,this tree is null");
+      if (tempNode === undefined)
+        throw new Error("don't find this key,this tree is empty");
       return tempNode.key;
     }
     getLastKey(): K {
       let tempNode = this._constitute.lastNode();
-      if (tempNode === null)
-        throw new Error("don't find this key,this tree is null");
+      if (tempNode === undefined)
+        throw new Error("don't find this key,this tree is empty");
       return tempNode.key;
     }
     setAll(map: TreeMap<K, V>) {
@@ -88,7 +91,7 @@ if (flag || fastTreeMap === undefined) {
     set(key: K, value: V): Object {
       return this._constitute.addNode(key, value);
     }
-    remove(key: K): V | null {
+    remove(key: K): V {
       return this._constitute.removeNode(key);
     }
     clear() {
@@ -96,11 +99,11 @@ if (flag || fastTreeMap === undefined) {
     }
     getLowerKey(key: K): K {
       let tempNode = this._constitute.getNode(key);
-      if (tempNode === null)
+      if (tempNode === undefined)
         throw new Error("don't find this key,this node is undefine");
-      if (tempNode.left !== null) return tempNode.left.key;
+      if (tempNode.left !== undefined) return tempNode.left.key;
       let node = tempNode;
-      while (node.parent !== null) {
+      while (node.parent !== undefined) {
         if (node.parent.right === node) return node.parent.key;
         node = node.parent;
       }
@@ -108,11 +111,11 @@ if (flag || fastTreeMap === undefined) {
     }
     getHigherKey(key: K): K {
       let tempNode = this._constitute.getNode(key);
-      if (tempNode === null)
+      if (tempNode === undefined)
         throw new Error("don't find this key,this node is undefine");
-      if (tempNode.right !== null) return tempNode.right.key;
+      if (tempNode.right !== undefined) return tempNode.right.key;
       let node = tempNode;
-      while (node.parent !== null) {
+      while (node.parent !== undefined) {
         if (node.parent.left === node) return node.parent.key;
         node = node.parent;
       }
@@ -120,11 +123,12 @@ if (flag || fastTreeMap === undefined) {
     }
     keys(): IterableIterator<K> {
       let data = this._constitute;
-      let i = 0;
+      let count = 0;
       return {
         next: function () {
-          var done = i >= data.memberNumber;
-          var value = !done ? data.keyValueArray[i++].key : undefined;
+          var done = count >= data.memberNumber;
+          var value = !done ? data.keyValueArray[count].key : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -134,11 +138,12 @@ if (flag || fastTreeMap === undefined) {
     }
     values(): IterableIterator<V> {
       let data = this._constitute;
-      let i = 0;
+      let count = 0;
       return {
         next: function () {
-          var done = i >= data.memberNumber;
-          var value = !done ? data.keyValueArray[i++].value as V : undefined;
+          var done = count >= data.memberNumber;
+          var value = !done ? data.keyValueArray[count].value : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -148,7 +153,7 @@ if (flag || fastTreeMap === undefined) {
     }
     replace(key: K, newValue: V): boolean {
       let targetNode = this._constitute.getNode(key);
-      if (targetNode === null) return false;
+      if (targetNode === undefined) return false;
       targetNode.value = newValue;
       return true;
     }
@@ -162,11 +167,12 @@ if (flag || fastTreeMap === undefined) {
     }
     entries(): IterableIterator<[K, V]> {
       let data = this._constitute;
-      let i = 0;
+      let count = 0;
       return {
         next: function () {
-          var done = i >= data.memberNumber;
-          var value = !done ? data.keyValueArray[i++].entry() : undefined;
+          var done = count >= data.memberNumber;
+          var value = !done ? data.keyValueArray[count].entry() : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -176,11 +182,12 @@ if (flag || fastTreeMap === undefined) {
     }
     [Symbol.iterator](): IterableIterator<[K, V]> {
       let data = this._constitute;
-      let i = 0;
+      let count = 0;
       return {
         next: function () {
-          var done = i >= data.memberNumber;
-          var value = !done ? data.keyValueArray[i++].entry() : undefined;
+          var done = count >= data.memberNumber;
+          var value = !done ? data.keyValueArray[count].entry() : undefined;
+          count++;
           return {
             done: done,
             value: value,
diff --git a/container/treeset/js_treeset.ts b/container/treeset/js_treeset.ts
index 070c28400f7fbcc9eaf52014bc9dd5ec95cc7e07..5f7d9405483b27e6d983ec3a6645ebbb50c41291 100644
--- a/container/treeset/js_treeset.ts
+++ b/container/treeset/js_treeset.ts
@@ -51,8 +51,8 @@ if (flag || fastTreeSet === undefined) {
   }
   class TreeSet<T> {
     private _constitute: any;
-    constructor() {
-      this._constitute = new RBTreeAbility.RBTreeClass();
+    constructor(comparator?: (firstValue: T, secondValue: T) => boolean) {
+      this._constitute = new RBTreeAbility.RBTreeClass(comparator);
       return new Proxy(this, new HandlerTreeSet());
     }
     get length() {
@@ -62,7 +62,7 @@ if (flag || fastTreeSet === undefined) {
       return this._constitute.isEmpty();
     }
     has(value: T): boolean {
-      return this._constitute.getNode(value) !== null;
+      return this._constitute.getNode(value) !== undefined;
     }
     add(value: T): boolean {
       this._constitute.addNode(value);
@@ -70,30 +70,30 @@ if (flag || fastTreeSet === undefined) {
     }
     remove(value: T): boolean {
       let result = this._constitute.removeNode(value);
-      return result !== null;
+      return result !== undefined;
     }
     clear() {
       this._constitute.clearTree();
     }
     getFirstValue(): T {
       let tempNode = this._constitute.firstNode();
-      if (tempNode === null)
-        throw new Error("don't find this key,this tree is null");
+      if (tempNode === undefined)
+        throw new Error("don't find this key,this tree is empty");
       return tempNode.key;
     }
     getLastValue(): T {
       let tempNode = this._constitute.lastNode();
-      if (tempNode === null)
-        throw new Error("don't find this key,this tree is null");
+      if (tempNode === undefined)
+        throw new Error("don't find this key,this tree is empty");
       return tempNode.key;
     }
     getLowerValue(key: T): T {
       let tempNode = this._constitute.getNode(key);
-      if (tempNode === null)
+      if (tempNode === undefined)
         throw new Error("don't find this key,this node is undefine");
-      if (tempNode.left !== null) return tempNode.left.key;
+      if (tempNode.left !== undefined) return tempNode.left.key;
       let node = tempNode;
-      while (node.parent !== null) {
+      while (node.parent !== undefined) {
         if (node.parent.right === node) return node.parent.key;
         node = node.parent; // node.parent.left === node is true;
       }
@@ -101,11 +101,11 @@ if (flag || fastTreeSet === undefined) {
     }
     getHigherValue(key: T): T {
       let tempNode = this._constitute.getNode(key);
-      if (tempNode === null)
+      if (tempNode === undefined)
         throw new Error("don't find this key,this node is undefine");
-      if (tempNode.right !== null) return tempNode.right.key;
+      if (tempNode.right !== undefined) return tempNode.right.key;
       let node = tempNode;
-      while (node.parent !== null) {
+      while (node.parent !== undefined) {
         if (node.parent.left === node) return node.parent.key;
         node = node.parent; // node.parent.right === node is true;
       }
@@ -113,7 +113,7 @@ if (flag || fastTreeSet === undefined) {
     }
     popFirst(): T {
       let firstNode = this._constitute.firstNode();
-      if (firstNode === null)
+      if (firstNode === undefined)
         throw new Error("don't find first node,this tree is empty");
       let value = firstNode.value;
       this._constitute.removeNodeProcess(firstNode);
@@ -121,7 +121,7 @@ if (flag || fastTreeSet === undefined) {
     }
     popLast(): T {
       let lastNode = this._constitute.lastNode();
-      if (lastNode === null)
+      if (lastNode === undefined)
         throw new Error("don't find last node,this tree is empty");
       let value = lastNode.value;
       this._constitute.removeNodeProcess(lastNode);
@@ -133,7 +133,8 @@ if (flag || fastTreeSet === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].value as T : undefined;
+          var value = !done ? data.keyValueArray[count].value as T : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -155,7 +156,8 @@ if (flag || fastTreeSet === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].entry() : undefined;
+          var value = !done ? data.keyValueArray[count].entry() : undefined;
+          count++;
           return {
             done: done,
             value: value,
@@ -169,7 +171,8 @@ if (flag || fastTreeSet === undefined) {
       return {
         next: function () {
           var done = count >= data.memberNumber;
-          var value = !done ? data.keyValueArray[count++].key : undefined;
+          var value = !done ? data.keyValueArray[count].key : undefined;
+          count++;
           return {
             done: done,
             value: value,
diff --git a/container/vector/js_vector.ts b/container/vector/js_vector.ts
index a37fe7f1f3252984b3cac56ebfa3e6f03b33a79f..a459bdb0897e481bc8488e468ad1282e852de922 100644
--- a/container/vector/js_vector.ts
+++ b/container/vector/js_vector.ts
@@ -145,11 +145,13 @@ if (flag || fastVector == undefined) {
     set(index: number, element: T): void {
       this[index] = element;
     }
-    removeByIndex(index: number): void {
+    removeByIndex(index: number): T {
+      let result = this[index];
       for (let i = index; i < this._length - 1; i++) {
         this[i] = this[i + 1];
       }
       this._length--;
+      return result;
     }
     remove(element: T): boolean {
       if (this.has(element)) {
@@ -270,6 +272,9 @@ if (flag || fastVector == undefined) {
       if (fromIndex >= toIndex) {
         throw new Error(`fromIndex cannot be less than or equal to toIndex`);
       }
+      if (fromIndex >= this._length || fromIndex < 0 || toIndex < 0) {
+        throw new Error(`fromIndex or toIndex is out-of-bounds`);
+      }
       toIndex = toIndex >= this._length - 1 ? this._length - 1 : toIndex;
       let vector = new Vector<T>();
       for (let i = fromIndex; i < toIndex; i++) {
@@ -300,7 +305,7 @@ if (flag || fastVector == undefined) {
     clone(): Vector<T> {
       let clone = new Vector<T>();
       for (let i = 0; i < this._length; i++) {
-        this.add(this[i]);
+        clone.add(this[i]);
       }
       return clone;
     }
@@ -321,15 +326,12 @@ if (flag || fastVector == undefined) {
     trimToCurrentLength(): void {
       this._capacity = this._length;
     }
-    setSize(newSize: number): void {
-      this._length = newSize;
-    }
     isEmpty(): boolean {
       return this._length == 0;
     }
     [Symbol.iterator](): IterableIterator<T> {
       let count = 0;
-      let vector = this
+      let vector = this;
       return {
         next: function () {
           var done = count >= vector._length;