diff --git a/src/main/java/xyz/zhouxy/plusone/commons/collection/CollectionTools.java b/src/main/java/xyz/zhouxy/plusone/commons/collection/CollectionTools.java
index ca079fe..2ca85f6 100644
--- a/src/main/java/xyz/zhouxy/plusone/commons/collection/CollectionTools.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/collection/CollectionTools.java
@@ -1,5 +1,6 @@
 package xyz.zhouxy.plusone.commons.collection;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -35,7 +36,7 @@ public class CollectionTools {
 
     // Collection -> Map
 
-    public static <K, V> HashMap<K, V> toHashMap(
+    public static <K, V> HashMap<K, V> toHashMap( // NOSONAR return implementation
             Iterable<V> c,
             Function<? super V, K> keyGenerator,
             int initialCapacity) {
@@ -44,7 +45,7 @@ public class CollectionTools {
         return map;
     }
 
-    public static <K, V> HashMap<K, V> toHashMap(
+    public static <K, V> HashMap<K, V> toHashMap( // NOSONAR return implementation
             Collection<V> c,
             Function<? super V, K> keyGenerator) {
         return toHashMap(c, keyGenerator, c.size());
@@ -65,7 +66,7 @@ public class CollectionTools {
         return toConcurrentHashMap(c, keyGenerator, c.size());
     }
 
-    public static <K extends Comparable<? super K>, V> TreeMap<K, V> toTreeMap(
+    public static <K extends Comparable<? super K>, V> TreeMap<K, V> toTreeMap( // NOSONAR return implementation
             Iterable<V> c,
             Function<? super V, K> keyGenerator) {
         TreeMap<K, V> map = new TreeMap<>();
@@ -73,7 +74,7 @@ public class CollectionTools {
         return map;
     }
 
-    public static <K, V> TreeMap<K, V> toTreeMap(
+    public static <K, V> TreeMap<K, V> toTreeMap( // NOSONAR return implementation
             Iterable<V> c,
             Function<? super V, K> keyGenerator,
             Comparator<? super K> keycComparator) {
@@ -95,6 +96,61 @@ public class CollectionTools {
         }
     }
 
+    // array -> map
+
+    public static <K, V> HashMap<K, V> toHashMap( // NOSONAR return implementation
+            V[] c,
+            Function<? super V, K> keyGenerator,
+            int initialCapacity) {
+        HashMap<K, V> map = new HashMap<>(initialCapacity);
+        fillIntoEmptyMap(map, c, keyGenerator);
+        return map;
+    }
+
+    public static <K, V> HashMap<K, V> toHashMap( // NOSONAR return implementation
+            V[] c,
+            Function<? super V, K> keyGenerator) {
+        return toHashMap(c, keyGenerator, c.length);
+    }
+
+    public static <K, V> SafeConcurrentHashMap<K, V> toConcurrentHashMap(
+            V[] c,
+            Function<? super V, K> keyGenerator,
+            int initialCapacity) {
+        SafeConcurrentHashMap<K, V> map = new SafeConcurrentHashMap<>(initialCapacity);
+        fillIntoEmptyMap(map, c, keyGenerator);
+        return map;
+    }
+
+    public static <K, V> SafeConcurrentHashMap<K, V> toConcurrentHashMap(
+            V[] c,
+            Function<? super V, K> keyGenerator) {
+        return toConcurrentHashMap(c, keyGenerator, c.length);
+    }
+
+    public static <K extends Comparable<? super K>, V> TreeMap<K, V> toTreeMap( // NOSONAR return implementation
+            V[] c,
+            Function<? super V, K> keyGenerator) {
+        TreeMap<K, V> map = new TreeMap<>();
+        fillIntoEmptyMap(map, c, keyGenerator);
+        return map;
+    }
+
+    public static <K, V> TreeMap<K, V> toTreeMap( // NOSONAR return implementation
+            V[] c,
+            Function<? super V, K> keyGenerator,
+            Comparator<? super K> keyComparator) {
+        TreeMap<K, V> map = new TreeMap<>(keyComparator);
+        fillIntoEmptyMap(map, c, keyGenerator);
+        return map;
+    }
+
+    public static <K, V> void fillIntoEmptyMap(
+            Map<K, ? super V> map, V[] c,
+            Function<? super V, K> keyGenerator) {
+        fillIntoEmptyMap(map, Arrays.asList(c), keyGenerator);
+    }
+
     private CollectionTools() {
         throw new IllegalStateException("Utility class");
     }
diff --git a/src/main/java/xyz/zhouxy/plusone/commons/collection/SynchronizedTable.java b/src/main/java/xyz/zhouxy/plusone/commons/collection/SynchronizedTable.java
deleted file mode 100644
index a4e2474..0000000
--- a/src/main/java/xyz/zhouxy/plusone/commons/collection/SynchronizedTable.java
+++ /dev/null
@@ -1,205 +0,0 @@
-package xyz.zhouxy.plusone.commons.collection;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
-import javax.annotation.concurrent.ThreadSafe;
-
-import com.google.common.annotations.Beta;
-import com.google.common.collect.ImmutableTable;
-import com.google.common.collect.Table;
-
-/**
- * 将 {@link Table} 包装为同步集合，线程安全。
- *
- * <p>
- * 可通过以下方式构建一个线程安全的 {@link Table}
- * </p>
- * 
- * <pre>
- * SynchronizedTable.of(HashBasedTable.create())
- * </pre>
- * 
- * <p>
- * <b>NOTE: 如果 {@link Table} 不需要更改，请使用 {@link ImmutableTable}</b>
- * </p>
- *
- * @author <a href="http://zhouxy.xyz:3000/ZhouXY108/">ZhouXY</a>
- * @since 0.1.0-SNAPSHOT
- * @see Table
- * @see ImmutableTable
- */
-@Beta
-@ThreadSafe
-public class SynchronizedTable<R, C, V> implements Table<R, C, V>, Serializable {
-
-    private static final long serialVersionUID = 3716653837549439569L;
-
-    @SuppressWarnings("serial")
-    private final Table<R, C, V> table;
-    @SuppressWarnings("serial")
-    private final Object mutex;
-
-    private SynchronizedTable(Table<R, C, V> table) {
-        this.table = Objects.requireNonNull(table);
-        this.mutex = this;
-    }
-
-    private SynchronizedTable(Table<R, C, V> table, Object mutex) {
-        this.table = Objects.requireNonNull(table);
-        this.mutex = mutex;
-    }
-
-    public static <R, C, V> SynchronizedTable<R, C, V> of(Table<R, C, V> table) {
-        if (table instanceof SynchronizedTable) {
-            return (SynchronizedTable<R, C, V>) table;
-        } else {
-            return new SynchronizedTable<>(table);
-        }
-    }
-
-    public static <R, C, V> SynchronizedTable<R, C, V> of(Table<R, C, V> table, Object mutex) {
-        if (table instanceof SynchronizedTable) {
-            SynchronizedTable<R, C, V> srcTable = (SynchronizedTable<R, C, V>) table;
-            return new SynchronizedTable<>(srcTable.table, mutex);
-        } else {
-            return new SynchronizedTable<>(table);
-        }
-    }
-
-    @Override
-    public boolean contains(Object rowKey, Object columnKey) {
-        synchronized (mutex) {
-            return this.table.contains(rowKey, columnKey);
-        }
-    }
-
-    @Override
-    public boolean containsRow(Object rowKey) {
-        synchronized (mutex) {
-            return this.table.containsRow(rowKey);
-        }
-    }
-
-    @Override
-    public boolean containsColumn(Object columnKey) {
-        synchronized (mutex) {
-            return this.table.containsColumn(columnKey);
-        }
-    }
-
-    @Override
-    public boolean containsValue(Object value) {
-        synchronized (mutex) {
-            return this.table.containsValue(value);
-        }
-    }
-
-    @Override
-    public V get(Object rowKey, Object columnKey) {
-        synchronized (mutex) {
-            return this.table.get(rowKey, columnKey);
-        }
-    }
-
-    @Override
-    public boolean isEmpty() {
-        synchronized (mutex) {
-            return this.table.isEmpty();
-        }
-    }
-
-    @Override
-    public int size() {
-        synchronized (mutex) {
-            return this.table.size();
-        }
-    }
-
-    @Override
-    public void clear() {
-        synchronized (mutex) {
-            this.table.clear();
-        }
-    }
-
-    @Override
-    public V put(R rowKey, C columnKey, V value) {
-        synchronized (mutex) {
-            return this.table.put(rowKey, columnKey, value);
-        }
-    }
-
-    @Override
-    public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
-        synchronized (mutex) {
-            this.table.putAll(table);
-        }
-    }
-
-    @Override
-    public V remove(Object rowKey, Object columnKey) {
-        synchronized (mutex) {
-            return this.table.remove(rowKey, columnKey);
-        }
-    }
-
-    @Override
-    public Map<C, V> row(R rowKey) {
-        synchronized (mutex) {
-            return this.table.row(rowKey);
-        }
-    }
-
-    @Override
-    public Map<R, V> column(C columnKey) {
-        synchronized (mutex) {
-            return this.table.column(columnKey);
-        }
-    }
-
-    @Override
-    public Set<Cell<R, C, V>> cellSet() {
-        synchronized (mutex) {
-            return this.table.cellSet();
-        }
-    }
-
-    @Override
-    public Set<R> rowKeySet() {
-        synchronized (mutex) {
-            return this.table.rowKeySet();
-        }
-    }
-
-    @Override
-    public Set<C> columnKeySet() {
-        synchronized (mutex) {
-            return this.table.columnKeySet();
-        }
-    }
-
-    @Override
-    public Collection<V> values() {
-        synchronized (mutex) {
-            return this.table.values();
-        }
-    }
-
-    @Override
-    public Map<R, Map<C, V>> rowMap() {
-        synchronized (mutex) {
-            return this.table.rowMap();
-        }
-    }
-
-    @Override
-    public Map<C, Map<R, V>> columnMap() {
-        synchronized (mutex) {
-            return this.table.columnMap();
-        }
-    }
-}