修正了一些格式

public/dicts/java-arraylist.json

@@ -2,151 +2,151 @@
     {
         "name": "add()",
         "trans": [
-            "将元素插入到指定位置的 arraylist 中"
+            "add():将元素插入到指定位置的 arraylist 中"
         ]
     },
     {
         "name": "addAll()",
         "trans": [
-            "添加集合中的所有元素到 arraylist 中"
+            "addAll():添加集合中的所有元素到 arraylist 中"
         ]
     },
     {
         "name": "clear()",
         "trans": [
-            "删除 arraylist 中的所有元素"
+            "clear():删除 arraylist 中的所有元素"
         ]
     },
     {
         "name": "clone()",
         "trans": [
-            "复制一份 arraylist"
+            "clone():复制一份 arraylist"
         ]
     },
     {
         "name": "contains()",
         "trans": [
-            "判断元素是否在 arraylist"
+            "contains():判断元素是否在 arraylist"
         ]
     },
     {
         "name": "get()",
         "trans": [
-            "通过索引值获取 arraylist 中的元素"
+            "get():通过索引值获取 arraylist 中的元素"
         ]
     },
     {
         "name": "indexOf()",
         "trans": [
-            "返回 arraylist 中元素的索引值"
+            "indexOf():返回 arraylist 中元素的索引值"
         ]
     },
     {
         "name": "removeAll()",
         "trans": [
-            "删除存在于指定集合中的 arraylist 里的所有元素"
+            "removeAll():删除存在于指定集合中的 arraylist 里的所有元素"
         ]
     },
     {
         "name": "remove()",
         "trans": [
-            "删除 arraylist 里的单个元素"
+            "remove():删除 arraylist 里的单个元素"
         ]
     },
     {
         "name": "size()",
         "trans": [
-            "返回 arraylist 里元素数量"
+            "size():返回 arraylist 里元素数量"
         ]
     },
     {
         "name": "isEmpty()",
         "trans": [
-            "判断 arraylist 是否为空"
+            "isEmpty():判断 arraylist 是否为空"
         ]
     },
     {
         "name": "subList()",
         "trans": [
-            "截取部分 arraylist 的元素"
+            "subList():截取部分 arraylist 的元素"
         ]
     },
     {
         "name": "set()",
         "trans": [
-            "替换 arraylist 中指定索引的元素"
+            "set():替换 arraylist 中指定索引的元素"
         ]
     },
     {
         "name": "sort()",
         "trans": [
-            "对 arraylist 元素进行排序"
+            "sort():对 arraylist 元素进行排序"
         ]
     },
     {
         "name": "toArray()",
         "trans": [
-            "将 arraylist 转换为数组"
+            "toArray():将 arraylist 转换为数组"
         ]
     },
     {
         "name": "toString()",
         "trans": [
-            "将 arraylist 转换为字符串"
+            "toString():将 arraylist 转换为字符串"
         ]
     },
     {
         "name": "ensureCapacity()",
         "trans": [
-            "设置指定容量大小的 arraylist"
+            "ensureCapacity():设置指定容量大小的 arraylist"
         ]
     },
     {
         "name": "lastIndexOf()",
         "trans": [
-            "返回指定元素在 arraylist 中最后一次出现的位置"
+            "lastIndexOf():返回指定元素在 arraylist 中最后一次出现的位置"
         ]
     },
     {
         "name": "retainAll()",
         "trans": [
-            "保留 arraylist 中在指定集合中也存在的那些元素"
+            "retainAll():保留 arraylist 中在指定集合中也存在的那些元素"
         ]
     },
     {
         "name": "containsAll()",
         "trans": [
-            "查看 arraylist 是否包含指定集合中的所有元素"
+            "containsAll():查看 arraylist 是否包含指定集合中的所有元素"
         ]
     },
     {
         "name": "trimToSize()",
         "trans": [
-            "将 arraylist 中的容量调整为数组中的元素个数"
+            "trimToSize():将 arraylist 中的容量调整为数组中的元素个数"
         ]
     },
     {
         "name": "removeRange()",
         "trans": [
-            "删除 arraylist 中指定索引之间存在的元素"
+            "removeRange():删除 arraylist 中指定索引之间存在的元素"
         ]
     },
     {
         "name": "replaceAll()",
         "trans": [
-            "将给定的操作内容替换掉数组中每一个元素"
+            "replaceAll():将给定的操作内容替换掉数组中每一个元素"
         ]
     },
     {
         "name": "removeIf()",
         "trans": [
-            "删除所有满足特定条件的 arraylist 元素"
+            "removeIf():删除所有满足特定条件的 arraylist 元素"
         ]
     },
     {
         "name": "forEach()",
         "trans": [
-            "遍历 arraylist 中每一个元素并执行特定操作"
+            "forEach():遍历 arraylist 中每一个元素并执行特定操作"
         ]
     }
 ]

public/dicts/java-hashmap.json

@@ -2,133 +2,133 @@
     {
         "name": "clear()",
         "trans": [
-            "删除 hashMap 中的所有键/值对"
+            "clear():删除 hashMap 中的所有键值对"
         ]
     },
     {
         "name": "clone()",
         "trans": [
-            "复制一份 hashMap"
+            "clone():复制一份 hashMap"
         ]
     },
     {
         "name": "isEmpty()",
         "trans": [
-            "判断 hashMap 是否为空"
+            "isEmpty():判断 hashMap 是否为空"
         ]
     },
     {
         "name": "size()",
         "trans": [
-            "计算 hashMap 中键/值对的数量"
+            "size():计算 hashMap 中键值对的数量"
         ]
     },
     {
         "name": "put()",
         "trans": [
-            "将键/值对添加到 hashMap 中"
+            "put():将键值对添加到 hashMap 中"
         ]
     },
     {
         "name": "putAll()",
         "trans": [
-            "将所有键/值对添加到 hashMap 中"
+            "putAll():将所有键值对添加到 hashMap 中"
         ]
     },
     {
         "name": "putIfAbsent()",
         "trans": [
-            "如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。"
+            "putIfAbsent():如果 hashMap 中不存在指定的键，则将指定的键值对插入到 hashMap 中。"
         ]
     },
     {
         "name": "remove()",
         "trans": [
-            "删除 hashMap 中指定键 key 的映射关系"
+            "remove():删除 hashMap 中指定键 key 的映射关系"
         ]
     },
     {
         "name": "containsKey()",
         "trans": [
-            "检查 hashMap 中是否存在指定的 key 对应的映射关系。"
+            "containsKey():检查 hashMap 中是否存在指定的 key 对应的映射关系。"
         ]
     },
     {
         "name": "containsValue()",
         "trans": [
-            "检查 hashMap 中是否存在指定的 value 对应的映射关系。"
+            "containsValue():检查 hashMap 中是否存在指定的 value 对应的映射关系。"
         ]
     },
     {
         "name": "replace()",
         "trans": [
-            "替换 hashMap 中是指定的 key 对应的 value。"
+            "replace():替换 hashMap 中是指定的 key 对应的 value。"
         ]
     },
     {
         "name": "replaceAll()",
         "trans": [
-            "将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。"
+            "replaceAll():将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。"
         ]
     },
     {
         "name": "get()",
         "trans": [
-            "获取指定 key 对应对 value"
+            "get():获取指定 key 对应对 value"
         ]
     },
     {
         "name": "getOrDefault()",
         "trans": [
-            "获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值"
+            "getOrDefault():获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值"
         ]
     },
     {
         "name": "forEach()",
         "trans": [
-            "对 hashMap 中的每个映射执行指定的操作。"
+            "forEach():对 hashMap 中的每个映射执行指定的操作。"
         ]
     },
     {
         "name": "entrySet()",
         "trans": [
-            "返回 hashMap 中所有映射项的集合集合视图。"
+            "entrySet():返回 hashMap 中所有映射项的集合集合视图。"
         ]
     },
     {
         "name": "keySet()",
         "trans": [
-            "返回 hashMap 中所有 key 组成的集合视图。"
+            "keySet():返回 hashMap 中所有 key 组成的集合视图。"
         ]
     },
     {
         "name": "values()",
         "trans": [
-            "返回 hashMap 中存在的所有 value 值。"
+            "values():返回 hashMap 中存在的所有 value 值。"
         ]
     },
     {
         "name": "merge()",
         "trans": [
-            "添加键值对到 hashMap 中"
+            "merge():添加键值对到 hashMap 中"
         ]
     },
     {
         "name": "compute()",
         "trans": [
-            "对 hashMap 中指定 key 的值进行重新计算"
+            "compute():对 hashMap 中指定 key 的值进行重新计算"
         ]
     },
     {
         "name": "computeIfAbsent()",
         "trans": [
-            "对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中"
+            "computeIfAbsent():对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中"
         ]
     },
     {
         "name": "computeIfPresent()",
         "trans": [
-            "对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。"
+            "computeIfPresent():对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。"
         ]
     }
 ]

public/dicts/java-linkedlist.json

@@ -1,200 +1,152 @@
 [
     {
-        "name": "public boolean add(E e)",
+        "name": "offerLast()",
         "trans": [
-            "链表末尾添加元素，返回是否成功，成功为 true，失败为 false。"
+            "public boolean offerLast(E e):尾部插入元素，返回是否成功，成功为 true，失败为 false。"
         ]
     },
     {
-        "name": "public void add(int index, E element)",
+        "name": "clear()",
         "trans": [
-            "向指定位置插入元素。"
+            "public void clear():清空链表。"
         ]
     },
     {
-        "name": "public boolean addAll(Collection extends E> c)",
+        "name": "removeFirst()",
         "trans": [
-            "将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。"
+            "public E removeFirst():删除并返回第一个元素。"
         ]
     },
     {
-        "name": "public boolean addAll(int index, Collection extends E> c)",
+        "name": "removeLast()",
         "trans": [
-            "将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。"
+            "public E removeLast():删除并返回最后一个元素。"
         ]
     },
     {
-        "name": "public void addFirst(E e)",
+        "name": "remove()",
         "trans": [
-            "元素添加到头部。"
+            "public boolean remove(Object o):删除某一元素，返回是否成功，成功为 true，失败为 false。"
         ]
     },
     {
-        "name": "public void addLast(E e)",
+        "name": "remove()",
         "trans": [
-            "元素添加到尾部。"
+            "public E remove(int index):删除指定位置的元素。"
         ]
     },
     {
-        "name": "public boolean offer(E e)",
+        "name": "poll()",
         "trans": [
-            "向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。"
+            "public E poll():删除并返回第一个元素。"
         ]
     },
     {
-        "name": "public boolean offerFirst(E e)",
+        "name": "remove()",
         "trans": [
-            "头部插入元素，返回是否成功，成功为 true，失败为 false。"
+            "public E remove():删除并返回第一个元素。"
         ]
     },
     {
-        "name": "public boolean offerLast(E e)",
+        "name": "contains()",
         "trans": [
-            "尾部插入元素，返回是否成功，成功为 true，失败为 false。"
+            "public boolean contains(Object o):判断是否含有某一元素。"
         ]
     },
     {
-        "name": "public void clear()",
+        "name": "get()",
         "trans": [
-            "清空链表。"
+            "public E get(int index):返回指定位置的元素。"
         ]
     },
     {
-        "name": "public E removeFirst()",
+        "name": "getFirst()",
         "trans": [
-            "删除并返回第一个元素。"
+            "public E getFirst():返回第一个元素。"
         ]
     },
     {
-        "name": "public E removeLast()",
+        "name": "getLast()",
         "trans": [
-            "删除并返回最后一个元素。"
+            "public E getLast():返回最后一个元素。"
         ]
     },
     {
-        "name": "public boolean remove(Object o)",
+        "name": "indexOf()",
         "trans": [
-            "删除某一元素，返回是否成功，成功为 true，失败为 false。"
+            "public int indexOf(Object o):查找指定元素从前往后第一次出现的索引。"
         ]
     },
     {
-        "name": "public E remove(int index)",
+        "name": "lastIndexOf()",
         "trans": [
-            "删除指定位置的元素。"
+            "public int lastIndexOf(Object o):查找指定元素最后一次出现的索引。"
         ]
     },
     {
-        "name": "public E poll()",
+        "name": "peek()",
         "trans": [
-            "删除并返回第一个元素。"
+            "public E peek():返回第一个元素。"
         ]
     },
     {
-        "name": "public E remove()",
+        "name": "element()",
         "trans": [
-            "删除并返回第一个元素。"
+            "public E element():返回第一个元素。"
         ]
     },
     {
-        "name": "public boolean contains(Object o)",
+        "name": "peekFirst()",
         "trans": [
-            "判断是否含有某一元素。"
+            "public E peekFirst():返回头部元素。"
         ]
     },
     {
-        "name": "public E get(int index)",
+        "name": "peekLast()",
         "trans": [
-            "返回指定位置的元素。"
+            "public E peekLast():返回尾部元素。"
         ]
     },
     {
-        "name": "public E getFirst()",
+        "name": "set()",
         "trans": [
-            "返回第一个元素。"
+            "public E set(int index, E element):设置指定位置的元素。"
         ]
     },
     {
-        "name": "public E getLast()",
+        "name": "clone()",
         "trans": [
-            "返回最后一个元素。"
+            "public Object clone():克隆该列表。"
         ]
     },
     {
-        "name": "public int indexOf(Object o)",
+        "name": "descendingIterator()",
         "trans": [
-            "查找指定元素从前往后第一次出现的索引。"
+            "public Iterator descendingIterator():返回倒序迭代器。"
         ]
     },
     {
-        "name": "public int lastIndexOf(Object o)",
+        "name": "size()",
         "trans": [
-            "查找指定元素最后一次出现的索引。"
+            "public int size():返回链表元素个数。"
         ]
     },
     {
-        "name": "public E peek()",
+        "name": "listIterator()",
         "trans": [
-            "返回第一个元素。"
+            "public ListIterator listIterator(int index):返回从指定位置开始到末尾的迭代器。"
         ]
     },
     {
-        "name": "public E element()",
+        "name": "toArray()",
         "trans": [
-            "返回第一个元素。"
+            "public Object[] toArray():返回一个由链表元素组成的数组。"
         ]
     },
     {
-        "name": "public E peekFirst()",
+        "name": "toArray()",
         "trans": [
-            "返回头部元素。"
-        ]
-    },
-    {
-        "name": "public E peekLast()",
-        "trans": [
-            "返回尾部元素。"
-        ]
-    },
-    {
-        "name": "public E set(int index, E element)",
-        "trans": [
-            "设置指定位置的元素。"
-        ]
-    },
-    {
-        "name": "public Object clone()",
-        "trans": [
-            "克隆该列表。"
-        ]
-    },
-    {
-        "name": "public Iterator descendingIterator()",
-        "trans": [
-            "返回倒序迭代器。"
-        ]
-    },
-    {
-        "name": "public int size()",
-        "trans": [
-            "返回链表元素个数。"
-        ]
-    },
-    {
-        "name": "public ListIterator listIterator(int index)",
-        "trans": [
-            "返回从指定位置开始到末尾的迭代器。"
-        ]
-    },
-    {
-        "name": "public Object[] toArray()",
-        "trans": [
-            "返回一个由链表元素组成的数组。"
-        ]
-    },
-    {
-        "name": "public  T[] toArray(T[] a)",
-        "trans": [
-            "返回一个由链表元素转换类型而成的数组。"
+            "public  T[] toArray(T[] a):返回一个由链表元素转换类型而成的数组。"
         ]
     }
 ]