From 978523f5ab5d598c612345576de143ac4bb53ff7 Mon Sep 17 00:00:00 2001
From: TimAndy <xuchonglei@126.com>
Date: Fri, 15 Feb 2019 13:14:03 +0800
Subject: [PATCH] optimize code

---
 .../com/alibaba/fastjson/util/TypeUtils.java  | 35 +++++++++----------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/src/main/java/com/alibaba/fastjson/util/TypeUtils.java b/src/main/java/com/alibaba/fastjson/util/TypeUtils.java
index 6b89a3495b..45f90166ce 100755
--- a/src/main/java/com/alibaba/fastjson/util/TypeUtils.java
+++ b/src/main/java/com/alibaba/fastjson/util/TypeUtils.java
@@ -2307,13 +2307,13 @@ private static Type getCollectionItemType(ParameterizedType parameterizedType) {
             return getWildcardTypeUpperBounds(actualTypeArguments[0]);
         }
         Class<?> rawClass = (Class<?>) rawType;
-        Map<TypeVariable, Type> typeParameterMap = createTypeParameterMap(rawClass.getTypeParameters(), actualTypeArguments);
+        Map<TypeVariable, Type> actualTypeMap = createActualTypeMap(rawClass.getTypeParameters(), actualTypeArguments);
         Type superType = getCollectionSuperType(rawClass);
         if (superType instanceof ParameterizedType) {
             Class<?> superClass = getRawClass(superType);
             Type[] superClassTypeParameters = ((ParameterizedType) superType).getActualTypeArguments();
             return superClassTypeParameters.length > 0
-                    ? getCollectionItemType(makeParameterizedType(superClass, superClassTypeParameters, typeParameterMap))
+                    ? getCollectionItemType(makeParameterizedType(superClass, superClassTypeParameters, actualTypeMap))
                     : getCollectionItemType(superClass);
         }
         return getCollectionItemType((Class<?>) superType);
@@ -2333,34 +2333,33 @@ private static Type getCollectionSuperType(Class<?> clazz) {
         return assignable == null ? clazz.getGenericSuperclass() : assignable;
     }
 
-    private static Map<TypeVariable, Type> createTypeParameterMap(TypeVariable[] typeParameters, Type[] actualTypeArguments) {
+    private static Map<TypeVariable, Type> createActualTypeMap(TypeVariable[] typeParameters, Type[] actualTypeArguments) {
         int length = typeParameters.length;
-        Map<TypeVariable, Type> typeParameterMap = new HashMap<TypeVariable, Type>(length);
+        Map<TypeVariable, Type> actualTypeMap = new HashMap<TypeVariable, Type>(length);
         for (int i = 0; i < length; i++) {
-            typeParameterMap.put(typeParameters[i], actualTypeArguments[i]);
+            actualTypeMap.put(typeParameters[i], actualTypeArguments[i]);
         }
-        return typeParameterMap;
+        return actualTypeMap;
     }
 
-    private static ParameterizedType makeParameterizedType(Class<?> rawClass, Type[] typeParameters, Map<TypeVariable, Type> typeParameterMap) {
+    private static ParameterizedType makeParameterizedType(Class<?> rawClass, Type[] typeParameters, Map<TypeVariable, Type> actualTypeMap) {
         int length = typeParameters.length;
         Type[] actualTypeArguments = new Type[length];
-        System.arraycopy(typeParameters, 0, actualTypeArguments, 0, length);
-        for (int i = 0; i < actualTypeArguments.length; i++) {
-            actualTypeArguments[i] = expandType(actualTypeArguments[i], typeParameterMap);
+        for (int i = 0; i < length; i++) {
+            actualTypeArguments[i] = getActualType(typeParameters[i], actualTypeMap);
         }
         return new ParameterizedTypeImpl(actualTypeArguments, null, rawClass);
     }
 
-    private static Type expandType(Type type, Map<TypeVariable, Type> typeParameterMap) {
-        if (type instanceof TypeVariable) {
-            return typeParameterMap.get(type);
-        } else if (type instanceof ParameterizedType) {
-            return makeParameterizedType(getRawClass(type), ((ParameterizedType) type).getActualTypeArguments(), typeParameterMap);
-        } else if (type instanceof GenericArrayType) {
-            return new GenericArrayTypeImpl(expandType(((GenericArrayType) type).getGenericComponentType(), typeParameterMap));
+    private static Type getActualType(Type typeParameter, Map<TypeVariable, Type> actualTypeMap) {
+        if (typeParameter instanceof TypeVariable) {
+            return actualTypeMap.get(typeParameter);
+        } else if (typeParameter instanceof ParameterizedType) {
+            return makeParameterizedType(getRawClass(typeParameter), ((ParameterizedType) typeParameter).getActualTypeArguments(), actualTypeMap);
+        } else if (typeParameter instanceof GenericArrayType) {
+            return new GenericArrayTypeImpl(getActualType(((GenericArrayType) typeParameter).getGenericComponentType(), actualTypeMap));
         }
-        return type;
+        return typeParameter;
     }
 
     private static Type getWildcardTypeUpperBounds(Type type) {