diff --git a/gradle.properties b/gradle.properties
index 3568e6e..a5cb525 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,3 +1,3 @@
 junitVersion=4.12
-vavrVersion=1.0.0-SNAPSHOT
+vavrVersion=0.10.3
 gsonVersion=2.8.0
diff --git a/src/main/java/io/vavr/gson/JsonArrayConverter.java b/src/main/java/io/vavr/gson/ArrayTypeConverter.java
similarity index 96%
rename from src/main/java/io/vavr/gson/JsonArrayConverter.java
rename to src/main/java/io/vavr/gson/ArrayTypeConverter.java
index 7ae3f51..298a540 100644
--- a/src/main/java/io/vavr/gson/JsonArrayConverter.java
+++ b/src/main/java/io/vavr/gson/ArrayTypeConverter.java
@@ -12,7 +12,7 @@
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 
-abstract class JsonArrayConverter<T> implements JsonSerializer<T>, JsonDeserializer<T>  {
+abstract class ArrayTypeConverter<T> implements JsonSerializer<T>, JsonDeserializer<T>  {
 
     private static final Type[] EMPTY_TYPES = new Type[0];
 
diff --git a/src/main/java/io/vavr/gson/JsonObjectConverter.java b/src/main/java/io/vavr/gson/JsonObjectConverter.java
deleted file mode 100644
index 20047cb..0000000
--- a/src/main/java/io/vavr/gson/JsonObjectConverter.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*                        __    __  __  __    __  ___
- *                       \  \  /  /    \  \  /  /  __/
- *                        \  \/  /  /\  \  \/  /  /
- *                         \____/__/  \__\____/__/.ɪᴏ
- * ᶜᵒᵖʸʳᶦᵍʰᵗ ᵇʸ ᵛᵃᵛʳ ⁻ ˡᶦᶜᵉⁿˢᵉᵈ ᵘⁿᵈᵉʳ ᵗʰᵉ ᵃᵖᵃᶜʰᵉ ˡᶦᶜᵉⁿˢᵉ ᵛᵉʳˢᶦᵒⁿ ᵗʷᵒ ᵈᵒᵗ ᶻᵉʳᵒ
- */
-package io.vavr.gson;
-
-import com.google.gson.*;
-import io.vavr.collection.Map;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-
-abstract class JsonObjectConverter<T> implements JsonSerializer<T>, JsonDeserializer<T>  {
-
-    private static final Type[] EMPTY_TYPES = new Type[0];
-
-    abstract T fromJsonObject(JsonObject arr, Type type, Type[] subTypes, JsonDeserializationContext ctx) throws JsonParseException;
-    abstract Map<?, ?> toMap(T src);
-
-    @Override
-    public T deserialize(JsonElement json, Type type, JsonDeserializationContext ctx) throws JsonParseException {
-        if (json.isJsonObject()) {
-            if (type instanceof ParameterizedType) {
-                ParameterizedType parameterizedType = (ParameterizedType) type;
-                Type[] types = parameterizedType.getActualTypeArguments();
-                return fromJsonObject(json.getAsJsonObject(), type, types, ctx);
-            } else {
-                return fromJsonObject(json.getAsJsonObject(), type, EMPTY_TYPES, ctx);
-            }
-        } else {
-            throw new JsonParseException("object expected");
-        }
-    }
-
-    @Override
-    public JsonElement serialize(T src, Type type, JsonSerializationContext ctx) {
-        return toMap(src).foldLeft(new JsonObject(), (a, e) -> {
-            a.add(ctx.serialize(e._1).getAsString(), ctx.serialize(e._2));
-            return a;
-        });
-    }
-}
diff --git a/src/main/java/io/vavr/gson/MapConverter.java b/src/main/java/io/vavr/gson/MapConverter.java
index 9724f64..9632d17 100644
--- a/src/main/java/io/vavr/gson/MapConverter.java
+++ b/src/main/java/io/vavr/gson/MapConverter.java
@@ -6,37 +6,94 @@
  */
 package io.vavr.gson;
 
-import com.google.gson.*;
-import io.vavr.Tuple;
-import io.vavr.Tuple2;
-import io.vavr.collection.Map;
-
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-class MapConverter<K, V, T extends Map<K, V>> extends JsonObjectConverter<T> {
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.reflect.TypeToken;
+import io.vavr.Tuple;
+import io.vavr.Tuple2;
+import io.vavr.collection.Map;
+import io.vavr.collection.Traversable;
+import io.vavr.collection.Vector;
 
-    private final Function<Iterable<Tuple2<String, ?>>, Map<?, ?>> factory;
+class MapConverter<K, V, T extends Map<K, V>> extends MapTypeConverter<T> {
 
-    MapConverter(Function<Iterable<Tuple2<String, ?>>, Map<?, ?>> factory) {
+    private final Function<Iterable<Tuple2<K, V>>, Map<K, V>> factory;
+
+    MapConverter(Function<Iterable<Tuple2<K, V>>, Map<K, V>> factory) {
         this.factory = factory;
     }
 
     @Override
     @SuppressWarnings("unchecked")
     T fromJsonObject(JsonObject obj, Type type, Type[] subTypes, JsonDeserializationContext ctx) throws JsonParseException {
-        Function<java.util.Map.Entry<String, JsonElement>, Tuple2<String, ?>> mapper;
+        Function<java.util.Map.Entry<String, JsonElement>, Tuple2<K, V>> mapper;
         if (subTypes.length == 2) {
-            mapper = e -> Tuple.of(ctx.deserialize(new JsonPrimitive(e.getKey()), subTypes[0]), ctx.deserialize(e.getValue(), subTypes[1]));
+            mapper = e -> convert(ctx, e, subTypes[0], subTypes[1]);
         } else {
-            mapper = e -> Tuple.of(e.getKey(), e.getValue());
+            mapper = e -> Tuple.of((K) e.getKey(), (V) e.getValue());
         }
-        return (T) factory.apply(obj.entrySet().stream().map(mapper).collect(Collectors.toList()));
+        final Set<java.util.Map.Entry<String, JsonElement>> entries = obj.entrySet();
+        final Iterable<Tuple2<K, V>> collect = entries.stream().map(mapper).collect(Collectors.toList());
+        return (T) factory.apply(collect);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    T fromJsonArray(JsonArray arr, Type type, Type[] subTypes, JsonDeserializationContext ctx) throws JsonParseException {
+        final Awkward tuple2KV = new Awkward(Tuple2.class, subTypes);
+        final Type traversableType = new TypeToken<Traversable<?>>() {
+        }.getType();
+        final Awkward traversableTuple2KV = new Awkward(traversableType, tuple2KV);
+        final TraversableConverter<Traversable<Tuple2<K, V>>> traversableConverter = new TraversableConverter<>(Vector::ofAll);
+        final Traversable<Tuple2<K, V>> tuple2s = traversableConverter.fromJsonArray(arr, traversableTuple2KV, traversableTuple2KV.getActualTypeArguments(), ctx);
+        return (T) factory.apply(tuple2s);
+    }
+
+    private Tuple2<K, V> convert(JsonDeserializationContext ctx, java.util.Map.Entry<String, JsonElement> e, Type keyType, Type valueType) {
+        final JsonPrimitive json = new JsonPrimitive(e.getKey());
+        final K key = ctx.deserialize(json, keyType);
+        final V value = ctx.deserialize(e.getValue(), valueType);
+        return Tuple.of(key, value);
     }
 
     @Override
     Map<K, V> toMap(T src) {
         return src;
     }
+
+    private static final class Awkward implements ParameterizedType {
+
+        private final Type rawType;
+        private final Type[] subTypes;
+
+        private Awkward(Type rawType, Type... subTypes) {
+            this.rawType = rawType;
+            this.subTypes = subTypes;
+        }
+
+        @Override
+        public Type[] getActualTypeArguments() {
+            return subTypes;
+        }
+
+        @Override
+        public Type getRawType() {
+            return rawType;
+        }
+
+        @Override
+        public Type getOwnerType() {
+            return null;
+        }
+    }
 }
diff --git a/src/main/java/io/vavr/gson/MapTypeConverter.java b/src/main/java/io/vavr/gson/MapTypeConverter.java
new file mode 100644
index 0000000..0730009
--- /dev/null
+++ b/src/main/java/io/vavr/gson/MapTypeConverter.java
@@ -0,0 +1,81 @@
+/*                        __    __  __  __    __  ___
+ *                       \  \  /  /    \  \  /  /  __/
+ *                        \  \/  /  /\  \  \/  /  /
+ *                         \____/__/  \__\____/__/.ɪᴏ
+ * ᶜᵒᵖʸʳᶦᵍʰᵗ ᵇʸ ᵛᵃᵛʳ ⁻ ˡᶦᶜᵉⁿˢᵉᵈ ᵘⁿᵈᵉʳ ᵗʰᵉ ᵃᵖᵃᶜʰᵉ ˡᶦᶜᵉⁿˢᵉ ᵛᵉʳˢᶦᵒⁿ ᵗʷᵒ ᵈᵒᵗ ᶻᵉʳᵒ
+ */
+package io.vavr.gson;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import io.vavr.collection.Map;
+
+import static jdk.nashorn.internal.runtime.JSType.isPrimitive;
+
+abstract class MapTypeConverter<T> implements JsonSerializer<T>, JsonDeserializer<T> {
+
+    private static final Type[] EMPTY_TYPES = new Type[0];
+
+    abstract T fromJsonObject(JsonObject arr, Type type, Type[] subTypes, JsonDeserializationContext ctx) throws JsonParseException;
+
+    abstract T fromJsonArray(JsonArray arr, Type type, Type[] subTypes, JsonDeserializationContext ctx) throws JsonParseException;
+
+    abstract Map<?, ?> toMap(T src);
+
+    @Override
+    public T deserialize(JsonElement json, Type type, JsonDeserializationContext ctx) throws JsonParseException {
+        if (json.isJsonObject()) {
+            if (type instanceof ParameterizedType) {
+                ParameterizedType parameterizedType = (ParameterizedType) type;
+                Type[] types = parameterizedType.getActualTypeArguments();
+                return fromJsonObject(json.getAsJsonObject(), type, types, ctx);
+            } else {
+                return fromJsonObject(json.getAsJsonObject(), type, EMPTY_TYPES, ctx);
+            }
+        } else if (json.isJsonArray()) {
+            // list of tuples
+            if (type instanceof ParameterizedType) {
+                ParameterizedType parameterizedType = (ParameterizedType) type;
+                Type[] types = parameterizedType.getActualTypeArguments();
+                return fromJsonArray(json.getAsJsonArray(), parameterizedType, types, ctx);
+            } else {
+                throw new JsonParseException("unsupported non-parameterised types for complex map keys");
+            }
+        } else {
+            throw new JsonParseException("object or array expected");
+        }
+    }
+
+    @Override
+    public JsonElement serialize(T src, Type type, JsonSerializationContext ctx) {
+        final Map<?, ?> tuple2s = toMap(src);
+        if (tuple2s.isEmpty()) {
+            return new JsonObject();
+        } else {
+            // test the first element
+            final Object o = tuple2s.head()._1();
+            // primitives are fine
+            if (isPrimitive(o)) {
+                return tuple2s.foldLeft(new JsonObject(), (a, e) -> {
+                    a.add(ctx.serialize(e._1).getAsString(), ctx.serialize(e._2));
+                    return a;
+                });
+            } else {
+                //complex object key serialisation
+                return tuple2s.foldLeft(new JsonArray(), (a, e) -> {
+                    a.add(ctx.serialize(e));
+                    return a;
+                });
+            }
+        }
+    }
+}
diff --git a/src/main/java/io/vavr/gson/MultimapConverter.java b/src/main/java/io/vavr/gson/MultimapConverter.java
index 36b94f4..8554569 100644
--- a/src/main/java/io/vavr/gson/MultimapConverter.java
+++ b/src/main/java/io/vavr/gson/MultimapConverter.java
@@ -6,7 +6,18 @@
  */
 package io.vavr.gson;
 
-import com.google.gson.*;
+import java.lang.reflect.Type;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonPrimitive;
 import io.vavr.Function1;
 import io.vavr.Tuple;
 import io.vavr.Tuple2;
@@ -15,13 +26,7 @@
 import io.vavr.collection.Map;
 import io.vavr.collection.Multimap;
 
-import java.lang.reflect.Type;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-class MultimapConverter<K, V, T extends Multimap<K, V>> extends JsonObjectConverter<T> {
+class MultimapConverter<K, V, T extends Multimap<K, V>> extends MapTypeConverter<T> {
 
     private final Function<Iterable<Tuple2<String, ?>>, Multimap<?, ?>> factory;
 
@@ -41,6 +46,12 @@ T fromJsonObject(JsonObject obj, Type type, Type[] subTypes, JsonDeserialization
         return (T) factory.apply(obj.entrySet().stream().flatMap(mapper).collect(Collectors.toList()));
     }
 
+    @Override
+    @SuppressWarnings("unchecked")
+    T fromJsonArray(JsonArray arr, Type type, Type[] subTypes, JsonDeserializationContext ctx) throws JsonParseException {
+        throw new UnsupportedOperationException("Array types not supported for Multimaps");
+    }
+
     @Override
     @SuppressWarnings("unchecked")
     Map<K, List<V>> toMap(T src) {
diff --git a/src/main/java/io/vavr/gson/OptionConverter.java b/src/main/java/io/vavr/gson/OptionConverter.java
index cd6d848..7f6dea7 100644
--- a/src/main/java/io/vavr/gson/OptionConverter.java
+++ b/src/main/java/io/vavr/gson/OptionConverter.java
@@ -15,7 +15,7 @@
 
 import java.lang.reflect.Type;
 
-class OptionConverter extends JsonArrayConverter<Option<?>> {
+class OptionConverter extends ArrayTypeConverter<Option<?>> {
 
     @Override
     Option<?> fromJsonArray(JsonArray arr, Type type, Type[] subTypes, JsonDeserializationContext ctx) throws JsonParseException {
diff --git a/src/main/java/io/vavr/gson/TraversableConverter.java b/src/main/java/io/vavr/gson/TraversableConverter.java
index ed632c0..d0f2552 100644
--- a/src/main/java/io/vavr/gson/TraversableConverter.java
+++ b/src/main/java/io/vavr/gson/TraversableConverter.java
@@ -15,7 +15,7 @@
 import java.lang.reflect.Type;
 import java.util.function.Function;
 
-class TraversableConverter<T extends Traversable<?>> extends JsonArrayConverter<T> {
+class TraversableConverter<T extends Traversable<?>> extends ArrayTypeConverter<T> {
 
     private final Function<Iterable<?>, Traversable<?>> factory;
 
diff --git a/src/main/java/io/vavr/gson/TupleConverter.java b/src/main/java/io/vavr/gson/TupleConverter.java
index a0c986c..c443d62 100644
--- a/src/main/java/io/vavr/gson/TupleConverter.java
+++ b/src/main/java/io/vavr/gson/TupleConverter.java
@@ -16,7 +16,7 @@
 
 import java.lang.reflect.Type;
 
-abstract class TupleConverter<T> extends JsonArrayConverter<T> {
+abstract class TupleConverter<T> extends ArrayTypeConverter<T> {
 
     static class N0 extends TupleConverter<Tuple0> {
 
diff --git a/src/main/java/io/vavr/gson/VavrGson.java b/src/main/java/io/vavr/gson/VavrGson.java
index 64398fd..1cb419c 100644
--- a/src/main/java/io/vavr/gson/VavrGson.java
+++ b/src/main/java/io/vavr/gson/VavrGson.java
@@ -9,6 +9,7 @@
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.Objects;
+import java.util.function.Function;
 
 import com.google.gson.GsonBuilder;
 import io.vavr.*;
@@ -378,10 +379,15 @@ public static Map<Type, Object> multiMapTypeAdapters() {
     public static Map<Type, Object> mapTypeAdapters() {
         return API.<Type, Object>Map()
                 .put(Map.class, new MapConverter<>(HashMap::ofEntries))
-                .put(SortedMap.class, new MapConverter<>(TreeMap::ofEntries))
+                .put(SortedMap.class, new MapConverter<>(VavrGson::getTreeMapMapper))
                 .put(HashMap.class, new MapConverter<>(HashMap::ofEntries))
                 .put(LinkedHashMap.class, new MapConverter<>(LinkedHashMap::ofEntries))
-                .put(TreeMap.class, new MapConverter<>(TreeMap::ofEntries));
+                .put(TreeMap.class, new MapConverter<>(VavrGson::getTreeMapMapper));
+    }
+
+
+    private static <K,V> TreeMap<K, V> getTreeMapMapper(Iterable<Tuple2<K, V>> i) {
+        return TreeMap.ofEntries((a, b) -> ((Comparable) a).compareTo(b), i);
     }
 
     public static Map<Type, Object> collectionTypeAdapters() {
diff --git a/src/test/java/io/vavr/gson/AbstractTest.java b/src/test/java/io/vavr/gson/AbstractTest.java
index a69701e..1e3d2a4 100644
--- a/src/test/java/io/vavr/gson/AbstractTest.java
+++ b/src/test/java/io/vavr/gson/AbstractTest.java
@@ -12,6 +12,7 @@ public class AbstractTest {
     public static void before() {
         GsonBuilder builder = new GsonBuilder();
         VavrGson.registerAll(builder);
+        builder = builder.enableComplexMapKeySerialization();
         gson = builder.create();
     }
 
diff --git a/src/test/java/io/vavr/gson/map/HashMapTest.java b/src/test/java/io/vavr/gson/map/HashMapTest.java
index 6c8cf6d..da9439f 100644
--- a/src/test/java/io/vavr/gson/map/HashMapTest.java
+++ b/src/test/java/io/vavr/gson/map/HashMapTest.java
@@ -1,16 +1,24 @@
 package io.vavr.gson.map;
 
+import java.lang.reflect.Type;
+
 import com.google.gson.reflect.TypeToken;
 import io.vavr.collection.HashMap;
+import io.vavr.collection.Map;
+import org.junit.Test;
 
-import java.lang.reflect.Type;
+public class HashMapTest extends MapLikeTest<HashMap<?, ?>> {
 
-public class HashMapTest extends MapLikeTest<HashMap<?,?>> {
     @Override
     HashMap<?, ?> of(Object key, Object value) {
         return HashMap.of(key, value);
     }
 
+    @Override
+    <K, V> Map<K, V> ofTyped(K key, V value) {
+        return HashMap.of(key, value);
+    }
+
     @Override
     Class<?> clz() {
         return HashMap.class;
@@ -18,11 +26,45 @@ Class<?> clz() {
 
     @Override
     Type type() {
-        return new TypeToken<HashMap<String, Integer>>(){}.getType();
+        return new TypeToken<HashMap<String, Integer>>() {
+        }.getType();
+    }
+
+    @Override
+    Type intType() {
+        return new TypeToken<HashMap<Integer, Integer>>() {
+        }.getType();
     }
 
     @Override
     Type typeWithNestedType() {
-        return new TypeToken<HashMap<String, HashMap<String, Integer>>>(){}.getType();
+        return new TypeToken<HashMap<String, HashMap<String, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type typeWithNestedIntType() {
+        return new TypeToken<HashMap<String, HashMap<Integer, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type getComplexNestedKeyType() {
+        return new TypeToken<HashMap<CustomKey, HashMap<CustomKey, Integer>>>() {
+        }.getType();
+    }
+
+    @Test
+    public void deserializeLongKey() {
+        Map<Long, Integer> map = gson.fromJson("{\"1\":2}", new TypeToken<HashMap<Long, Integer>>(){}.getType());
+        assert clz().isAssignableFrom(map.getClass());
+        assert map.get(1L).get() == 2;
+    }
+
+    @Test
+    public void deserializeDoubleKey() {
+        Map<Double, Integer> map = gson.fromJson("{\"1.323\":2}", new TypeToken<HashMap<Double, Integer>>(){}.getType());
+        assert clz().isAssignableFrom(map.getClass());
+        assert map.get(1.323D).get() == 2;
     }
 }
diff --git a/src/test/java/io/vavr/gson/map/LinkedHashMapTest.java b/src/test/java/io/vavr/gson/map/LinkedHashMapTest.java
index db9d02a..c154170 100644
--- a/src/test/java/io/vavr/gson/map/LinkedHashMapTest.java
+++ b/src/test/java/io/vavr/gson/map/LinkedHashMapTest.java
@@ -1,16 +1,23 @@
 package io.vavr.gson.map;
 
+import java.lang.reflect.Type;
+
 import com.google.gson.reflect.TypeToken;
 import io.vavr.collection.LinkedHashMap;
+import io.vavr.collection.Map;
 
-import java.lang.reflect.Type;
+public class LinkedHashMapTest extends MapLikeTest<LinkedHashMap<?, ?>> {
 
-public class LinkedHashMapTest extends MapLikeTest<LinkedHashMap<?,?>> {
     @Override
     LinkedHashMap<?, ?> of(Object key, Object value) {
         return LinkedHashMap.of(key, value);
     }
 
+    @Override
+    <K, V> Map<K, V> ofTyped(K key, V value) {
+        return LinkedHashMap.of(key, value);
+    }
+
     @Override
     Class<?> clz() {
         return LinkedHashMap.class;
@@ -18,11 +25,31 @@ Class<?> clz() {
 
     @Override
     Type type() {
-        return new TypeToken<LinkedHashMap<String, Integer>>(){}.getType();
+        return new TypeToken<LinkedHashMap<String, Integer>>() {
+        }.getType();
     }
 
     @Override
     Type typeWithNestedType() {
-        return new TypeToken<LinkedHashMap<String, LinkedHashMap<String, Integer>>>(){}.getType();
+        return new TypeToken<LinkedHashMap<String, LinkedHashMap<String, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type intType() {
+        return new TypeToken<LinkedHashMap<Integer, Integer>>() {
+        }.getType();
+    }
+
+    @Override
+    Type typeWithNestedIntType() {
+        return new TypeToken<LinkedHashMap<String, LinkedHashMap<Integer, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type getComplexNestedKeyType() {
+        return new TypeToken<LinkedHashMap<CustomKey, LinkedHashMap<CustomKey, Integer>>>() {
+        }.getType();
     }
 }
diff --git a/src/test/java/io/vavr/gson/map/MapLikeTest.java b/src/test/java/io/vavr/gson/map/MapLikeTest.java
index 0aa726c..9cd0621 100644
--- a/src/test/java/io/vavr/gson/map/MapLikeTest.java
+++ b/src/test/java/io/vavr/gson/map/MapLikeTest.java
@@ -1,20 +1,34 @@
 package io.vavr.gson.map;
 
+import java.lang.reflect.Type;
+import java.util.Comparator;
+import java.util.Objects;
+
 import com.google.gson.JsonParseException;
 import com.google.gson.JsonPrimitive;
+import io.vavr.collection.HashMap;
 import io.vavr.collection.Map;
 import io.vavr.gson.AbstractTest;
 import org.junit.Test;
 
-import java.lang.reflect.Type;
-
-public abstract class MapLikeTest<T extends Map<?,?>> extends AbstractTest {
+public abstract class MapLikeTest<T extends Map<?, ?>> extends AbstractTest {
 
     abstract T of(Object key, Object value);
+
+    abstract <K,V> Map<K,V> ofTyped(K key, V value);
+
     abstract Class<?> clz();
+
     abstract Type type();
+
+    abstract Type intType();
+
     abstract Type typeWithNestedType();
 
+    abstract Type typeWithNestedIntType();
+
+    abstract Type getComplexNestedKeyType();
+
     @Test(expected = JsonParseException.class)
     public void badJson() {
         gson.fromJson("1", type());
@@ -41,6 +55,13 @@ public void deserialize() {
         assert map.get("1").get() == 2;
     }
 
+    @Test
+    public void deserializeIntegerKey() {
+        Map<Integer, Integer> map = gson.fromJson("{\"1\":2}", intType());
+        assert clz().isAssignableFrom(map.getClass());
+        assert map.get(1).get() == 2;
+    }
+
     @Test
     public void deserializeWithCast() {
         Map<String, Integer> map = gson.fromJson("{\"1\":\"2\"}", type());
@@ -54,4 +75,75 @@ public void deserializeNested() {
         assert clz().isAssignableFrom(map.get("1").get().getClass());
         assert map.get("1").get().get("2").get() == 3;
     }
+
+    @Test
+    public void deserializeNestedIntegerKey() {
+        Map<String, Map<Integer, Integer>> map = gson.fromJson("{\"1\":{\"2\":3}}", typeWithNestedIntType());
+        assert clz().isAssignableFrom(map.get("1").get().getClass());
+        assert map.get("1").get().get(2).get() == 3;
+    }
+
+    @Test
+    public void deserializeNestedComplexKey() {
+        final CustomKey innerKey = new CustomKey(3, 4);
+        final CustomKey outerKey = new CustomKey(1, 2);
+        Map<CustomKey, Map<CustomKey, Integer>> map = gson.fromJson("[[{\"a\":1,\"b\":2},[[{\"a\":3,\"b\":4},5]]]]", getComplexNestedKeyType());
+        assert clz().isAssignableFrom(map.get(outerKey).get().getClass());
+        assert map.get(outerKey).get().get(innerKey).get() == 5;
+    }
+
+    @Test
+    public void serializeNestedComplexKey() {
+        final CustomKey innerKey = new CustomKey(3, 4);
+        final Map<CustomKey, Integer> innerMap = ofTyped(innerKey, 5);
+        final CustomKey outerKey = new CustomKey(1, 2);
+        final Map<CustomKey, Map<CustomKey, Integer>> vavrMap = ofTyped(outerKey, innerMap);
+        Map<CustomKey, Map<CustomKey, Integer>> map = gson.fromJson(gson.toJson(vavrMap), getComplexNestedKeyType());
+        assert clz().isAssignableFrom(map.get(outerKey).get().getClass());
+        assert map.get(outerKey).get().get(innerKey).get() == 5;
+    }
+
+    static final class CustomKey implements Comparable<CustomKey> {
+
+        private final int a;
+        private final int b;
+
+        public CustomKey(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        public int getA() {
+            return a;
+        }
+
+        public int getB() {
+            return b;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            CustomKey customKey = (CustomKey) o;
+            return a == customKey.a &&
+                   b == customKey.b;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(a, b);
+        }
+
+        @Override
+        public int compareTo(CustomKey o) {
+            return Comparator.comparingInt(CustomKey::getA)
+                             .thenComparing(CustomKey::getB)
+                             .compare(this, o);
+        }
+    }
 }
diff --git a/src/test/java/io/vavr/gson/map/MapTest.java b/src/test/java/io/vavr/gson/map/MapTest.java
index 5a85958..c9e2411 100644
--- a/src/test/java/io/vavr/gson/map/MapTest.java
+++ b/src/test/java/io/vavr/gson/map/MapTest.java
@@ -1,17 +1,23 @@
 package io.vavr.gson.map;
 
+import java.lang.reflect.Type;
+
 import com.google.gson.reflect.TypeToken;
 import io.vavr.collection.HashMap;
 import io.vavr.collection.Map;
 
-import java.lang.reflect.Type;
+public class MapTest extends MapLikeTest<Map<?, ?>> {
 
-public class MapTest extends MapLikeTest<Map<?,?>> {
     @Override
     Map<?, ?> of(Object key, Object value) {
         return HashMap.of(key, value);
     }
 
+    @Override
+    <K, V> Map<K, V> ofTyped(K key, V value) {
+        return HashMap.of(key, value);
+    }
+
     @Override
     Class<?> clz() {
         return Map.class;
@@ -19,11 +25,31 @@ Class<?> clz() {
 
     @Override
     Type type() {
-        return new TypeToken<Map<String, Integer>>(){}.getType();
+        return new TypeToken<Map<String, Integer>>() {
+        }.getType();
     }
 
     @Override
     Type typeWithNestedType() {
-        return new TypeToken<Map<String, Map<String, Integer>>>(){}.getType();
+        return new TypeToken<Map<String, Map<String, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type intType() {
+        return new TypeToken<Map<Integer, Integer>>() {
+        }.getType();
+    }
+
+    @Override
+    Type typeWithNestedIntType() {
+        return new TypeToken<Map<String, Map<Integer, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type getComplexNestedKeyType() {
+        return new TypeToken<Map<CustomKey, Map<CustomKey, Integer>>>() {
+        }.getType();
     }
 }
diff --git a/src/test/java/io/vavr/gson/map/SortedMapTest.java b/src/test/java/io/vavr/gson/map/SortedMapTest.java
index 051db02..454c8e9 100644
--- a/src/test/java/io/vavr/gson/map/SortedMapTest.java
+++ b/src/test/java/io/vavr/gson/map/SortedMapTest.java
@@ -1,18 +1,30 @@
 package io.vavr.gson.map;
 
+import java.lang.reflect.Type;
+
 import com.google.gson.reflect.TypeToken;
+import io.vavr.collection.Map;
 import io.vavr.collection.SortedMap;
 import io.vavr.collection.TreeMap;
 
-import java.lang.reflect.Type;
+public class SortedMapTest extends MapLikeTest<SortedMap<?, ?>> {
 
-public class SortedMapTest extends MapLikeTest<SortedMap<?,?>> {
     @Override
     @SuppressWarnings("unchecked")
     SortedMap<?, ?> of(Object key, Object value) {
         return TreeMap.of((Comparable) key, value);
     }
 
+    @Override
+    @SuppressWarnings("unchecked")
+    <K, V> Map<K, V> ofTyped(K key, V value) {
+        if (key instanceof Comparable) {
+            final Comparable typedKey = (Comparable<K>) key;
+            final Map<?, ?> of = TreeMap.of(typedKey, value);
+            return (Map<K, V>) of;
+        } else throw new IllegalArgumentException("Must be Comparable");
+    }
+
     @Override
     Class<?> clz() {
         return SortedMap.class;
@@ -20,11 +32,31 @@ Class<?> clz() {
 
     @Override
     Type type() {
-        return new TypeToken<SortedMap<String, Integer>>(){}.getType();
+        return new TypeToken<SortedMap<String, Integer>>() {
+        }.getType();
     }
 
     @Override
     Type typeWithNestedType() {
-        return new TypeToken<SortedMap<String, SortedMap<String, Integer>>>(){}.getType();
+        return new TypeToken<SortedMap<String, SortedMap<String, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type intType() {
+        return new TypeToken<SortedMap<Integer, Integer>>() {
+        }.getType();
+    }
+
+    @Override
+    Type typeWithNestedIntType() {
+        return new TypeToken<SortedMap<String, SortedMap<Integer, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type getComplexNestedKeyType() {
+        return new TypeToken<SortedMap<CustomKey, SortedMap<CustomKey, Integer>>>() {
+        }.getType();
     }
 }
diff --git a/src/test/java/io/vavr/gson/map/TreeMapTest.java b/src/test/java/io/vavr/gson/map/TreeMapTest.java
index 530c997..c5ae612 100644
--- a/src/test/java/io/vavr/gson/map/TreeMapTest.java
+++ b/src/test/java/io/vavr/gson/map/TreeMapTest.java
@@ -1,17 +1,29 @@
 package io.vavr.gson.map;
 
+import java.lang.reflect.Type;
+
 import com.google.gson.reflect.TypeToken;
+import io.vavr.collection.Map;
 import io.vavr.collection.TreeMap;
 
-import java.lang.reflect.Type;
+public class TreeMapTest extends MapLikeTest<TreeMap<?, ?>> {
 
-public class TreeMapTest extends MapLikeTest<TreeMap<?,?>> {
     @Override
     @SuppressWarnings("unchecked")
     TreeMap<?, ?> of(Object key, Object value) {
         return TreeMap.of((Comparable) key, value);
     }
 
+    @Override
+    @SuppressWarnings("unchecked")
+    <K , V> Map<K, V> ofTyped(K key, V value) {
+        if (key instanceof Comparable) {
+            final Comparable typedKey = (Comparable<K>) key;
+            final Map<?, ?> of = TreeMap.of(typedKey, value);
+            return (Map<K, V>) of;
+        } else throw new IllegalArgumentException("Must be Comparable");
+    }
+
     @Override
     Class<?> clz() {
         return TreeMap.class;
@@ -19,11 +31,31 @@ Class<?> clz() {
 
     @Override
     Type type() {
-        return new TypeToken<TreeMap<String, Integer>>(){}.getType();
+        return new TypeToken<TreeMap<String, Integer>>() {
+        }.getType();
     }
 
     @Override
     Type typeWithNestedType() {
-        return new TypeToken<TreeMap<String, TreeMap<String, Integer>>>(){}.getType();
+        return new TypeToken<TreeMap<String, TreeMap<String, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type intType() {
+        return new TypeToken<TreeMap<Integer, Integer>>() {
+        }.getType();
+    }
+
+    @Override
+    Type typeWithNestedIntType() {
+        return new TypeToken<TreeMap<String, TreeMap<Integer, Integer>>>() {
+        }.getType();
+    }
+
+    @Override
+    Type getComplexNestedKeyType() {
+        return new TypeToken<TreeMap<CustomKey, TreeMap<CustomKey, Integer>>>() {
+        }.getType();
     }
 }