// GsonBuilder负责配置参数
Gson gson = new GsonBuilder().setPrettyPrinting()          // 配置JSON美化输出.excludeFieldsWithoutExposeAnnotation() // 配置只处理带@Expose注解的字段.registerTypeAdapter(Date.class, new DateTypeAdapter()) // 注册自定义类型适配器.create(); // 创建不可变的Gson实例// Gson实例负责执行序列化/反序列化
String json = gson.toJson(myObject);
MyType obj = gson.fromJson(json, MyType.class);

// Gson类的构造函数使用参数对象初始化，创建后不可变
public final class Gson {private final List<TypeAdapterFactory> factories;private final FieldNamingStrategy fieldNamingStrategy;private final LongSerializationPolicy longSerializationPolicy;// 其他不可变配置字段...Gson(List<TypeAdapterFactory> factories,FieldNamingStrategy fieldNamingStrategy,LongSerializationPolicy longSerializationPolicy,// 其他参数...) {this.factories = factories;this.fieldNamingStrategy = fieldNamingStrategy;this.longSerializationPolicy = longSerializationPolicy;// 初始化其他字段...}// 所有配置相关方法均由GsonBuilder提供
}

public final class Gson {// 存储所有已注册的TypeAdapterFactoryprivate final List<TypeAdapterFactory> factories;// 根据类型获取对应的TypeAdapterpublic <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {// 从缓存中查找适配器TypeAdapter<?> cached = typeTokenCache.get(type);if (cached != null) {return (TypeAdapter<T>) cached;}// 缓存未命中时，遍历工厂列表查找匹配的工厂for (TypeAdapterFactory factory : factories) {TypeAdapter<T> candidate = factory.create(this, type);if (candidate != null) {// 找到匹配的工厂后，缓存适配器并返回typeTokenCache.put(type, candidate);return candidate;}}throw new IllegalArgumentException("Gson cannot handle " + type);}
}

public final class Gson {// 将对象序列化为JSON并写入指定的JsonWriterpublic void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {// 获取类型适配器TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));// 调用适配器的write方法进行序列化((TypeAdapter<Object>) adapter).write(writer, src);}// 从JsonReader读取JSON并反序列化为对象public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {// 获取类型适配器TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfT));// 调用适配器的read方法进行反序列化return (T) adapter.read(reader);}
}

public final class Gson {// 使用反射创建对象实例private final ConstructorConstructor constructorConstructor;// 处理带泛型的类型public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {// 创建TypeToken保存泛型信息TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);// 使用保存的泛型信息获取适配器TypeAdapter<T> adapter = getAdapter(typeToken);// 执行反序列化return adapter.fromJson(json);}
}

public final class GsonBuilder {// 配置参数private boolean serializeNulls = false;private boolean prettyPrinting = false;private boolean lenient = false;private boolean generateNonExecutableJson = false;private boolean escapeHtmlChars = true;private LongSerializationPolicy longSerializationPolicy = LongSerializationPolicy.DEFAULT;private FieldNamingStrategy fieldNamingPolicy = FieldNamingPolicy.IDENTITY;private final List<ExclusionStrategy> exclusionStrategies = new ArrayList<>();private final List<TypeAdapterFactory> factories = new ArrayList<>();private final Map<Type, InstanceCreator<?>> instanceCreators = new LinkedHashMap<>();// 其他配置参数...// 设置是否序列化null值public GsonBuilder serializeNulls() {this.serializeNulls = true;return this;}// 设置是否美化输出JSONpublic GsonBuilder setPrettyPrinting() {this.prettyPrinting = true;return this;}// 设置JSON解析是否宽松模式public GsonBuilder setLenient() {this.lenient = true;return this;}// 注册自定义类型适配器public <T> GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {// 验证typeAdapter是否为JsonSerializer或JsonDeserializer的实例if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {// 创建适配器工厂并添加到工厂列表factories.add(TypeAdapters.newFactory(TypeToken.get(type), typeAdapter));} else if (typeAdapter instanceof TypeAdapter) {// 直接添加TypeAdapter工厂factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter<?>) typeAdapter));} else {throw new IllegalArgumentException("Expected a TypeAdapter, JsonSerializer or JsonDeserializer");}return this;}// 创建Gson实例public Gson create() {// 构建最终的TypeAdapter工厂列表List<TypeAdapterFactory> factories = buildFactories();// 创建并返回Gson实例return new Gson(factories,instanceCreators,serializeNulls,generateNonExecutableJson,escapeHtmlChars,prettyPrinting,lenient,fieldNamingPolicy,longSerializationPolicy,exclusionStrategies,// 其他配置参数...);}// 构建完整的工厂列表，包括内置工厂和用户注册的工厂private List<TypeAdapterFactory> buildFactories() {List<TypeAdapterFactory> factories = new ArrayList<>();// 1. 添加用户注册的序列化器/反序列化器工厂（最高优先级）factories.addAll(this.factories);// 2. 添加内置的核心工厂factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);factories.add(ObjectTypeAdapter.FACTORY);// 3. 添加集合类型工厂factories.add(new CollectionTypeAdapterFactory(constructorConstructor));factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));// 4. 添加反射类型工厂（处理普通Java对象）factories.add(new ReflectiveTypeAdapterFactory(constructorConstructor,fieldNamingPolicy,exclusionStrategies,jsonAdapterFactory));// 5. 添加其他内置工厂...return Collections.unmodifiableList(factories);}
}

// GsonBuilder的buildFactories方法片段
private List<TypeAdapterFactory> buildFactories() {List<TypeAdapterFactory> factories = new ArrayList<>();// 1. 添加用户注册的工厂（按注册顺序，先注册的优先级高）factories.addAll(this.factories);// 2. 添加内置工厂（固定顺序）factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);factories.add(ObjectTypeAdapter.FACTORY);factories.add(new CollectionTypeAdapterFactory(constructorConstructor));factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));factories.add(new ReflectiveTypeAdapterFactory(constructorConstructor,fieldNamingPolicy,exclusionStrategies,jsonAdapterFactory));return Collections.unmodifiableList(factories);
}

public final class Gson {// 最核心的序列化方法，将对象序列化为JSON并写入JsonWriterpublic void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {// 获取对象的类型适配器TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));// 设置JsonWriter的宽松模式boolean oldLenient = writer.isLenient();writer.setLenient(true);try {// 调用适配器的write方法执行序列化((TypeAdapter<Object>) adapter).write(writer, src);} catch (IOException e) {throw new JsonIOException(e);} finally {// 恢复JsonWriter的原始宽松模式设置writer.setLenient(oldLenient);}}// 常用的序列化方法，将对象转换为JSON字符串public String toJson(Object src) {if (src == null) {return toJson(JsonNull.INSTANCE);}// 获取对象的实际类型Type typeOfSrc = src.getClass();return toJson(src, typeOfSrc);}// 将对象按照指定类型转换为JSON字符串public String toJson(Object src, Type typeOfSrc) {StringWriter writer = new StringWriter();toJson(src, typeOfSrc, writer);return writer.toString();}// 将对象按照指定类型序列化为JSON并写入Appendablepublic void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException {try {// 创建JsonWriter包装AppendableJsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer));toJson(src, typeOfSrc, jsonWriter);} catch (IOException e) {throw new JsonIOException(e);}}
}

public final class Gson {// 类型适配器缓存，提高性能private final ConcurrentMap<TypeToken<?>, TypeAdapter<?>> typeTokenCache = new ConcurrentHashMap<>();// 根据TypeToken获取对应的TypeAdapterpublic <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {// 首先从缓存中查找适配器TypeAdapter<?> cached = typeTokenCache.get(type);if (cached != null) {return (TypeAdapter<T>) cached;}// 缓存未命中时，处理可能的递归调用（防止循环引用）Map<TypeToken<?>, TypeAdapter<?>> threadCalls = calls.get();boolean requiresThreadLocalCleanup = false;if (threadCalls == null) {threadCalls = new HashMap<>();calls.set(threadCalls);requiresThreadLocalCleanup = true;}// 检查是否正在处理当前类型（防止循环引用导致的栈溢出）TypeAdapter<?> candidate = threadCalls.get(type);if (candidate != null) {return (TypeAdapter<T>) candidate;}try {// 标记正在处理当前类型threadCalls.put(type, null);// 遍历工厂列表，查找能够处理该类型的工厂for (TypeAdapterFactory factory : factories) {TypeAdapter<T> candidateAdapter = factory.create(this, type);if (candidateAdapter != null) {// 找到匹配的工厂后，缓存适配器并返回typeTokenCache.put(type, candidateAdapter);return candidateAdapter;}}// 没有找到合适的工厂，抛出异常throw new IllegalArgumentException("Gson cannot handle " + type);} finally {// 移除正在处理的标记threadCalls.remove(type);// 清理线程本地存储if (requiresThreadLocalCleanup) {calls.remove();}}}
}

public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {// 反射类型适配器的实现static final class Adapter<T> extends TypeAdapter<T> {private final ObjectConstructor<T> constructor;private final Map<String, BoundField> boundFields;Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {this.constructor = constructor;this.boundFields = boundFields;}@Overridepublic T read(JsonReader in) throws IOException {// 反序列化实现...}@Overridepublic void write(JsonWriter out, T value) throws IOException {if (value == null) {out.nullValue();return;}// 开始写入JSON对象out.beginObject();try {// 遍历所有绑定的字段for (BoundField boundField : boundFields.values()) {// 检查字段是否应该被序列化if (boundField.writeField(value)) {// 写入字段名out.name(boundField.name);// 写入字段值boundField.write(out, value);}}} catch (IllegalAccessException e) {throw new AssertionError(e);}// 结束写入JSON对象out.endObject();}}// 绑定字段类，封装了字段的序列化和反序列化逻辑abstract static class BoundField {final String name;final boolean serialized;final boolean deserialized;protected BoundField(String name, boolean serialized, boolean deserialized) {this.name = name;this.serialized = serialized;this.deserialized = deserialized;}// 检查字段是否应该被序列化abstract boolean writeField(Object value) throws IOException, IllegalAccessException;// 写入字段值abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException;// 读取字段值abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException;}
}

// 集合类型适配器工厂
public final class CollectionTypeAdapterFactory implements TypeAdapterFactory {private final ConstructorConstructor constructorConstructor;public CollectionTypeAdapterFactory(ConstructorConstructor constructorConstructor) {this.constructorConstructor = constructorConstructor;}@Overridepublic <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {Type type = typeToken.getType();// 检查是否为集合类型Class<? super T> rawType = typeToken.getRawType();if (!Collection.class.isAssignableFrom(rawType)) {return null;}// 获取集合元素的类型Type elementType = $Gson$Types.getCollectionElementType(type, rawType);TypeAdapter<?> elementTypeAdapter = gson.getAdapter(TypeToken.get(elementType));// 创建集合的实例构造器ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);// 创建集合类型适配器@SuppressWarnings({"unchecked", "rawtypes"})TypeAdapter<T> result = new Adapter(gson, elementType, elementTypeAdapter, constructor);return result;}// 集合类型适配器实现private static final class Adapter<E> extends TypeAdapter<Collection<E>> {private final TypeAdapter<E> elementTypeAdapter;private final ObjectConstructor<? extends Collection<E>> constructor;Adapter(Gson context, Type elementType,TypeAdapter<E> elementTypeAdapter,ObjectConstructor<? extends Collection<E>> constructor) {this.elementTypeAdapter =new TypeAdapterRuntimeTypeWrapper<>(context, elementTypeAdapter, elementType);this.constructor = constructor;}@Overridepublic Collection<E> read(JsonReader in) throws IOException {// 反序列化实现...}@Overridepublic void write(JsonWriter out, Collection<E> collection) throws IOException {if (collection == null) {out.nullValue();return;}// 开始写入JSON数组out.beginArray();// 遍历集合并序列化每个元素for (E element : collection) {elementTypeAdapter.write(out, element);}// 结束写入JSON数组out.endArray();}}
}// 映射类型适配器工厂
public final class MapTypeAdapterFactory implements TypeAdapterFactory {private final ConstructorConstructor constructorConstructor;private final boolean complexMapKeySerialization;public MapTypeAdapterFactory(ConstructorConstructor constructorConstructor,boolean complexMapKeySerialization) {this.constructorConstructor = constructorConstructor;this.complexMapKeySerialization = complexMapKeySerialization;}@Overridepublic <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {Type type = typeToken.getType();// 检查是否为映射类型Class<? super T> rawType = typeToken.getRawType();if (!Map.class.isAssignableFrom(rawType)) {return null;}// 获取映射键和值的类型Type[] keyAndValueTypes = $Gson$Types.getMapKeyAndValueTypes(type, rawType);TypeAdapter<?> keyAdapter = getKeyAdapter(gson, keyAndValueTypes[0]);TypeAdapter<?> valueAdapter = gson.getAdapter(TypeToken.get(keyAndValueTypes[1]));// 创建映射的实例构造器ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);// 创建映射类型适配器@SuppressWarnings({"unchecked", "rawtypes"})TypeAdapter<T> result = new Adapter(gson, keyAndValueTypes[0], keyAdapter,keyAndValueTypes[1], valueAdapter, constructor);return result;}// 获取键的适配器，处理特殊情况private TypeAdapter<?> getKeyAdapter(Gson context, Type keyType) {// 对于基本类型的键，使用特殊处理if (keyType == boolean.class || keyType == Boolean.class) {return TypeAdapters.BOOLEAN_AS_STRING;}if (keyType == char.class || keyType == Character.class) {return TypeAdapters.STRING;}if (keyType == Number.class) {return TypeAdapters.STRING;}// 对于其他类型的键，使用默认适配器TypeAdapter<?> adapter = context.getAdapter(TypeToken.get(keyType));if (!(adapter instanceof StringTypeAdapter)) {adapter = new StringAdapter(adapter);}return adapter;}// 映射类型适配器实现private static final class Adapter<K, V> extends TypeAdapter<Map<K, V>> {private final TypeAdapter<K> keyTypeAdapter;private final TypeAdapter<V> valueTypeAdapter;private final ObjectConstructor<? extends Map<K, V>> constructor;Adapter(Gson context, Type keyType, TypeAdapter<K> keyTypeAdapter,Type valueType, TypeAdapter<V> valueTypeAdapter,ObjectConstructor<? extends Map<K, V>> constructor) {this.keyTypeAdapter = new TypeAdapterRuntimeTypeWrapper<>(context, keyTypeAdapter, keyType);this.valueTypeAdapter = new TypeAdapterRuntimeTypeWrapper<>(context, valueTypeAdapter, valueType);this.constructor = constructor;}@Overridepublic Map<K, V> read(JsonReader in) throws IOException {// 反序列化实现...}@Overridepublic void write(JsonWriter out, Map<K, V> map) throws IOException {if (map == null) {out.nullValue();return;}// 开始写入JSON对象out.beginObject();// 遍历映射并序列化每个键值对for (Map.Entry<K, V> entry : map.entrySet()) {// 序列化键String key = keyTypeAdapter.toJsonTree(entry.getKey()).getAsString();// 写入键out.name(key);// 序列化并写入值valueTypeAdapter.write(out, entry.getValue());}// 结束写入JSON对象out.endObject();}}
}

public final class Gson {// 最核心的反序列化方法，从JsonReader读取JSON并反序列化为对象public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {boolean isEmpty = true;boolean oldLenient = reader.isLenient();reader.setLenient(true);try {// 检查JSON是否有内容reader.peek();isEmpty = false;// 获取类型适配器TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfT));// 调用适配器的read方法执行反序列化T result = (T) adapter.read(reader);// 确保JSON被完全消耗assertFullConsumption(reader, typeOfT);return result;} catch (EOFException e) {// 处理空JSON的情况if (isEmpty) {return null;}throw new JsonSyntaxException(e);} catch (IllegalStateException e) {throw new JsonSyntaxException(e);} catch (IOException e) {throw new JsonIOException(e);} catch (AssertionError e) {throw new JsonIOException(e);} finally {// 恢复JsonReader的原始宽松模式设置reader.setLenient(oldLenient);}}// 常用的反序列化方法，从JSON字符串反序列化为对象public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {if (json == null) {return null;}// 创建StringReader读取JSON字符串StringReader reader = new StringReader(json);// 调用核心反序列化方法return fromJson(reader, typeOfT);}// 从Reader反序列化为对象public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {// 创建JsonReader包装ReaderJsonReader jsonReader = newJsonReader(json);// 调用核心反序列化方法return fromJson(jsonReader, typeOfT);}// 从JSON字符串反序列化为对象（使用Class指定类型）public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {if (json == null) {return null;}// 创建StringReader读取JSON字符串StringReader reader = new StringReader(json);// 调用核心反序列化方法return fromJson(reader, classOfT);}
}

public final class Gson {// 从JsonReader读取JSON并反序列化为对象public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {// ... 前置代码 ...// 获取类型适配器（与序列化共享同一缓存和查找逻辑）TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfT));// 调用适配器的read方法执行反序列化T result = (T) adapter.read(reader);// ... 后置代码 ...}
}

public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {// 反射类型适配器的实现static final class Adapter<T> extends TypeAdapter<T> {private final ObjectConstructor<T> constructor;private final Map<String, BoundField> boundFields;Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {this.constructor = constructor;this.boundFields = boundFields;}@Overridepublic T read(JsonReader in) throws IOException {// 处理JSON为null的情况if (in.peek() == JsonToken.NULL) {in.nextNull();return null;}// 创建对象实例T instance = constructor.construct();try {// 开始解析JSON对象in.beginObject();// 遍历JSON对象的所有属性while (in.hasNext()) {// 读取属性名String name = in.nextName();// 查找匹配的绑定字段BoundField field = boundFields.get(name);if (field == null || !field.deserialized) {// 没有找到匹配的字段或字段不需要反序列化，跳过in.skipValue();} else {// 读取字段值field.read(in, instance);}}} catch (IllegalStateException e) {throw new JsonSyntaxException(e);} catch (IllegalAccessException e) {throw new AssertionError(e);}// 结束解析JSON对象in.endObject();return instance;}@Overridepublic void write(JsonWriter out, T value) throws IOException {// 序列化实现...}}// 绑定字段类，封装了字段的序列化和反序列化逻辑abstract static class BoundField {final String name;final boolean serialized;final boolean deserialized;final boolean isPrimitive;protected BoundField(String name, boolean serialized, boolean deserialized, boolean isPrimitive) {this.name = name;this.serialized = serialized;this.deserialized = deserialized;this.isPrimitive = isPrimitive;}// 检查字段是否应该被序列化abstract boolean writeField(Object value) throws IOException, IllegalAccessException;// 写入字段值abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException;// 读取字段值abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException;}
}

// 集合类型适配器工厂
public final class CollectionTypeAdapterFactory implements TypeAdapterFactory {// ... 工厂代码 ...// 集合类型适配器实现private static final class Adapter<E> extends TypeAdapter<Collection<E>> {private final TypeAdapter<E> elementTypeAdapter;private final ObjectConstructor<? extends Collection<E>> constructor;@Overridepublic Collection<E> read(JsonReader in) throws IOException {// 处理JSON为null的情况if (in.peek() == JsonToken.NULL) {in.nextNull();return null;}// 创建集合实例Collection<E> collection = constructor.construct();// 开始解析JSON数组in.beginArray();// 遍历JSON数组的每个元素while (in.hasNext()) {// 反序列化元素并添加到集合中E instance = elementTypeAdapter.read(in);collection.add(instance);}// 结束解析JSON数组in.endArray();return collection;}@Overridepublic void write(JsonWriter out, Collection<E> collection) throws IOException {// 序列化实现...}}
}// 映射类型适配器工厂
public final class MapTypeAdapterFactory implements TypeAdapterFactory {// ... 工厂代码 ...// 映射类型适配器实现private static final class Adapter<K, V> extends TypeAdapter<Map<K, V>> {private final TypeAdapter<K> keyTypeAdapter;private final TypeAdapter<V> valueTypeAdapter;private final ObjectConstructor<? extends Map<K, V>> constructor;@Overridepublic Map<K, V> read(JsonReader in) throws IOException {// 处理JSON为null的情况if (in.peek() == JsonToken.NULL) {in.nextNull();return null;}// 创建映射实例Map<K, V> map = constructor.construct();// 开始解析JSON对象in.beginObject();// 遍历JSON对象的所有属性while (in.hasNext()) {// 读取属性名（键）String keyStr = in.nextName();// 反序列化键K key = keyTypeAdapter.fromJsonTree(new JsonPrimitive(keyStr));// 反序列化值V value = valueTypeAdapter.read(in);// 将键值对添加到映射中map.put(key, value);}// 结束解析JSON对象in.endObject();return map;}@Overridepublic void write(JsonWriter out, Map<K, V> map) throws IOException {// 序列化实现...}}
}

// 字段命名策略接口
public interface FieldNamingStrategy {// 将Java字段名转换为JSON属性名public String translateName(Field f);
}// 内置的字段命名策略实现
public enum FieldNamingPolicy implements FieldNamingStrategy {// 使用字段的原始名称IDENTITY {@Overridepublic String translateName(Field f) {return f.getName();}},// 将字段名转换为小写，并用下划线分隔LOWER_CASE_WITH_UNDERSCORES {@Overridepublic String translateName(Field f) {return separateCamelCase(f.getName(), "_").toLowerCase();}},// 将字段名转换为小写，并用连字符分隔LOWER_CASE_WITH_DASHES {@Overridepublic String translateName(Field f) {return separateCamelCase(f.getName(), "-").toLowerCase();}},// 将字段名转换为大写，并用下划线分隔UPPER_CASE_WITH_UNDERSCORES {@Overridepublic String translateName(Field f) {return separateCamelCase(f.getName(), "_").toUpperCase();}},// 将字段名的首字母大写UPPER_CAMEL_CASE {@Overridepublic String translateName(Field f) {return modifyString(0, f.getName(), Character::toUpperCase);}},// 将字段名的首字母大写，并添加前缀UPPER_CAMEL_CASE_WITH_SPACES {@Overridepublic String translateName(Field f) {return separateCamelCase(f.getName(), " ");}};// 辅助方法：将驼峰命名转换为分隔符命名private static String separateCamelCase(String name, String separator) {StringBuilder translation = new StringBuilder();for (int i = 0; i < name.length(); i++) {char character = name.charAt(i);if (Character.isUpperCase(character) && translation.length() != 0) {translation.append(separator);}translation.append(character);}return translation.toString();}// 辅助方法：修改字符串特定位置的字符private static String modifyString(int offset, String string, Function<Character, Character> modifier) {StringBuilder result = new StringBuilder(string);result.setCharAt(offset, modifier.apply(result.charAt(offset)));return result.toString();}
}

// 排除策略接口
public interface ExclusionStrategy {// 是否

// 排除策略接口
public interface ExclusionStrategy {// 是否排除指定的类boolean shouldSkipClass(Class<?> clazz);// 是否排除指定的字段boolean shouldSkipField(FieldAttributes f);
}// 字段属性接口，封装了字段的元数据
public interface FieldAttributes {// 获取字段名String getName();// 获取字段的声明类型Class<?> getDeclaringClass();// 获取字段的类型Class<?> getType();// 获取字段的泛型类型Type getGenericType();// 检查字段是否有指定的注解boolean hasModifier(int modifier);// 获取字段上的指定注解<T extends Annotation> T getAnnotation(Class<T> annotation);// 检查字段是否有任何注解boolean hasAnnotations();
}// 内置的排除策略实现
class ModifierBasedExclusionStrategy implements ExclusionStrategy {private final int modifiers;public ModifierBasedExclusionStrategy(int modifiers) {this.modifiers = modifiers;}@Overridepublic boolean shouldSkipField(FieldAttributes f) {// 检查字段是否有指定的修饰符return (f.getModifiers() & modifiers) != 0;}@Overridepublic boolean shouldSkipClass(Class<?> clazz) {return false;}
}// 处理@Expose注解的排除策略
class ExposeAnnotationExclusionStrategy implements ExclusionStrategy {@Overridepublic boolean shouldSkipField(FieldAttributes f) {Expose expose = f.getAnnotation(Expose.class);return expose == null || (!expose.serialize() && !expose.deserialize());}@Overridepublic boolean shouldSkipClass(Class<?> clazz) {return false;}
}// 处理@Since和@Until注解的版本排除策略
class VersionExclusionStrategy implements ExclusionStrategy {private final double version;public VersionExclusionStrategy(double version) {this.version = version;}@Overridepublic boolean shouldSkipField(FieldAttributes f) {Since since = f.getAnnotation(Since.class);if (since != null && since.value() > version) {return true;}Until until = f.getAnnotation(Until.class);return until != null && until.value() <= version;}@Overridepublic boolean shouldSkipClass(Class<?> clazz) {Since since = clazz.getAnnotation(Since.class);if (since != null && since.value() > version) {return true;}Until until = clazz.getAnnotation(Until.class);return until != null && until.value() <= version;}
}

public final class GsonBuilder {// 注册针对特定类型的适配器public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {// 验证typeAdapter是否为合法类型if (typeAdapter instanceof TypeAdapter) {factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter<?>) typeAdapter));} else if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {TypeToken<?> typeToken = TypeToken.get(type);factories.add(TypeAdapters.newFactoryWithMatchRawType(typeToken,typeAdapter,matchRawType));} else {throw new IllegalArgumentException("Expected a TypeAdapter, JsonSerializer or JsonDeserializer");}return this;}// 注册针对类型层次结构的适配器public GsonBuilder registerTypeHierarchyAdapter(Class<?> baseType, Object typeAdapter) {if (typeAdapter instanceof TypeAdapter) {factories.add(TypeAdapters.newTypeHierarchyFactory(baseType, (TypeAdapter<?>) typeAdapter));} else if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {factories.add(TypeAdapters.newJsonSerializerDeserializer(baseType,(JsonSerializer<?>) typeAdapter,(JsonDeserializer<?>) typeAdapter));} else {throw new IllegalArgumentException("Expected a TypeAdapter, JsonSerializer or JsonDeserializer");}return this;}
}

// TypeToken类：保存泛型类型信息
public abstract class TypeToken<T> {final Type type;final Class<? super T> rawType;final int hashCode;// 受保护的构造函数，强制子类通过匿名内部类实现protected TypeToken() {this.type = getSuperclassTypeParameter(getClass());this.rawType = (Class<? super T>) $Gson$Types.getRawType(type);this.hashCode = type.hashCode();}// 私有构造函数，用于直接创建TypeTokenprivate TypeToken(Type type) {this.type = $Gson$Types.canonicalize(type);this.rawType = (Class<? super T>) $Gson$Types.getRawType(this.type);this.hashCode = this.type.hashCode();}// 获取泛型类型信息public final Type getType() {return type;}// 获取原始类型public final Class<? super T> getRawType() {return rawType;}// 静态工厂方法，创建TypeToken实例public static TypeToken<?> get(Type type) {return new TypeToken<Object>(type) {};}// 获取类的泛型父类的类型参数static Type getSuperclassTypeParameter(Class<?> subclass) {Type superclass = subclass.getGenericSuperclass();if (superclass instanceof Class) {throw new RuntimeException("Missing type parameter.");}ParameterizedType parameterized = (ParameterizedType) superclass;return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);}// 其他方法...
}

public final class GsonBuilder {// 使用特定的日期格式public GsonBuilder setDateFormat(String pattern) {this.datePattern = pattern;this.dateStyle = null;this.timeStyle = null;return this;}// 使用特定的日期风格public GsonBuilder setDateFormat(int style) {this.dateStyle = style;this.timeStyle = style;this.datePattern = null;return this;}// 使用特定的日期和时间风格public GsonBuilder setDateFormat(int dateStyle, int timeStyle) {this.dateStyle = dateStyle;this.timeStyle = timeStyle;this.datePattern = null;return this;}// 注册自定义的日期适配器public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {if (type == Date.class) {// 处理日期类型的适配器注册if (typeAdapter instanceof TypeAdapter) {factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter<?>) typeAdapter));} else if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {// 处理JsonSerializer和JsonDeserializer// ...}}return this;}
}// 内置的日期适配器
class DateTypeAdapter extends TypeAdapter<Date> {private final DateFormat enUsFormat;private final DateFormat localFormat;private final DateFormat iso8601Format;public DateTypeAdapter() {this.enUsFormat = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.US);this.localFormat = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT);this.iso8601Format = buildIso8601Format();}private static DateFormat buildIso8601Format() {DateFormat iso8601Format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);iso8601Format.setTimeZone(TimeZone.getTimeZone("UTC"));return iso8601Format;}@Overridepublic Date read(JsonReader in) throws IOException {if (in.peek() == JsonToken.NULL) {in.nextNull();return null;}return deserializeToDate(in.nextString());}private Date deserializeToDate(String json) {synchronized (enUsFormat) {try {// 尝试使用ISO 8601格式解析return iso8601Format.parse(json);} catch (ParseException e) {try {// 尝试使用本地格式解析return localFormat.parse(json);} catch (ParseException e2) {try {// 尝试使用US格式解析return enUsFormat.parse(json);} catch (ParseException e3) {throw new JsonSyntaxException(json, e3);}}}}}@Overridepublic void write(JsonWriter out, Date value) throws IOException {if (value == null) {out.nullValue();return;}synchronized (enUsFormat) {// 使用ISO 8601格式序列化String dateFormatAsString = iso8601Format.format(value);out.value(dateFormatAsString);}}
}

public final class Gson {// 所有配置参数在构造时初始化，之后不可变private final List<TypeAdapterFactory> factories;private final FieldNamingStrategy fieldNamingStrategy;private final LongSerializationPolicy longSerializationPolicy;// 其他配置字段...public Gson(List<TypeAdapterFactory> factories,FieldNamingStrategy fieldNamingStrategy,LongSerializationPolicy longSerializationPolicy,// 其他参数...) {// 初始化配置字段this.factories = factories;this.fieldNamingStrategy = fieldNamingStrategy;this.longSerializationPolicy = longSerializationPolicy;// 初始化其他字段...}// 所有公共方法都是无状态的，不修改Gson实例的内部状态public String toJson(Object src) {// 序列化实现...}public <T> T fromJson(String json, Class<T> classOfT) {// 反序列化实现...}
}

public final class Gson {// 类型适配器缓存private final ConcurrentMap<TypeToken<?>, TypeAdapter<?>> typeTokenCache = new ConcurrentHashMap<>();// 获取类型适配器，先检查缓存public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {// 从缓存中查找适配器TypeAdapter<?> cached = typeTokenCache.get(type);if (cached != null) {return (TypeAdapter<T>) cached;}// 缓存未命中时，创建新的适配器并缓存TypeAdapter<T> newAdapter = createAdapter(type);TypeAdapter<?> previous = typeTokenCache.putIfAbsent(type, newAdapter);return previous != null ? (TypeAdapter<T>) previous : newAdapter;}// 创建新的类型适配器private <T> TypeAdapter<T> createAdapter(TypeToken<T> type) {// 遍历工厂列表，查找能够处理该类型的工厂for (TypeAdapterFactory factory : factories) {TypeAdapter<T> candidate = factory.create(this, type);if (candidate != null) {return candidate;}}// 没有找到合适的工厂，抛出异常throw new IllegalArgumentException("Gson cannot handle " + type);}
}

// 构造函数工厂，用于创建对象实例
public final class ConstructorConstructor {private final Map<Type, InstanceCreator<?>> instanceCreators;public ConstructorConstructor(Map<Type, InstanceCreator<?>> instanceCreators) {this.instanceCreators = instanceCreators;}// 获取创建指定类型实例的工厂public <T> ObjectConstructor<T> get(TypeToken<T> typeToken) {final Type type = typeToken.getType();final Class<? super T> rawType = typeToken.getRawType();// 1. 检查是否有注册的InstanceCreatorfinal InstanceCreator<T> typeCreator = (InstanceCreator<T>) instanceCreators.get(type);if (typeCreator != null) {return () -> typeCreator.createInstance(type);}// 2. 检查是否有注册的原始类型的InstanceCreatorfinal InstanceCreator<T> rawTypeCreator = (InstanceCreator<T>) instanceCreators.get(rawType);if (rawTypeCreator != null) {return () -> rawTypeCreator.createInstance(type);}// 3. 使用反射创建无参构造函数的实例ObjectConstructor<T> defaultConstructor = newDefaultConstructor(rawType);if (defaultConstructor != null) {return defaultConstructor;}// 4. 使用反射创建有参构造函数的实例ObjectConstructor<T> defaultImplementation = newDefaultImplementationConstructor(type, rawType);if (defaultImplementation != null) {return defaultImplementation;}// 5. 使用Unsafe创建实例（性能最优，但需要特殊权限）return newUnsafeAllocator(type, rawType);}// 使用反射创建无参构造函数的实例private <T> ObjectConstructor<T> newDefaultConstructor(Class<? super T> rawType) {try {// 获取无参构造函数final Constructor<? super T> constructor = rawType.getDeclaredConstructor();// 检查构造函数的可访问性if (!constructor.isAccessible()) {constructor.setAccessible(true);}// 返回构造函数工厂return () -> {try {return (T) constructor.newInstance();} catch (InstantiationException e) {throw new RuntimeException("Failed to invoke " + constructor + " with no args", e);} catch (InvocationTargetException e) {throw new RuntimeException("Failed to invoke " + constructor + " with no args", e.getTargetException());} catch (IllegalAccessException e) {throw new AssertionError(e);}};} catch (NoSuchMethodException e) {return null;}}// 使用Unsafe创建实例private <T> ObjectConstructor<T> newUnsafeAllocator(final Type type, final Class<? super T> rawType) {return () -> {try {// 使用Unsafe.allocateInstance创建实例，不调用构造函数return (T) unsafe.allocateInstance(rawType);} catch (InstantiationException e) {throw new RuntimeException("Unable to create instance of " + type, e);}};}
}

// 使用流式API解析JSON
public void parseJsonStream(String json) throws IOException {JsonReader reader = new JsonReader(new StringReader(json));// 开始解析reader.beginObject();while (reader.hasNext()) {String name = reader.nextName();if (name.equals("name")) {String value = reader.nextString();// 处理name字段} else if (name.equals("age")) {int value = reader.nextInt();// 处理age字段} else {reader.skipValue(); // 跳过不关心的字段}}// 结束解析reader.endObject();reader.close();
}// 使用流式API生成JSON
public String generateJsonStream() throws IOException {StringWriter stringWriter = new StringWriter();JsonWriter writer = new JsonWriter(stringWriter);// 开始生成JSON对象writer.beginObject();// 添加name字段writer.name("name").value("John Doe");// 添加age字段writer.name("age").value(30);// 添加hobbies数组writer.name("hobbies").beginArray();writer.value("reading");writer.value("swimming");writer.value("coding");writer.endArray();// 结束生成JSON对象writer.endObject();writer.close();return stringWriter.toString();
}

// GsonConverterFactory类
public final class GsonConverterFactory extends Converter.Factory {private final Gson gson;private GsonConverterFactory(Gson gson) {this.gson = gson;}// 创建GsonConverterFactory实例public static GsonConverterFactory create() {return create(new Gson());}public static GsonConverterFactory create(Gson gson) {return new GsonConverterFactory(gson);}// 创建响应体转换器@Overridepublic Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));return new GsonResponseBodyConverter<>(gson, adapter);}// 创建请求体转换器@Overridepublic Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));return new GsonRequestBodyConverter<>(gson, adapter);}
}// 响应体转换器
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {private final Gson gson;private final TypeAdapter<T> adapter;GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {this.gson = gson;this.adapter = adapter;}@Overridepublic T convert(ResponseBody value) throws IOException {JsonReader jsonReader = gson.newJsonReader(value.charStream());try {return adapter.read(jsonReader);} finally {value.close();}}
}// 请求体转换器
final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {private final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");private final Charset UTF_8 = Charset.forName("UTF-8");private final Gson gson;private final TypeAdapter<T> adapter;GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {this.gson = gson;this.adapter = adapter;}@Overridepublic RequestBody convert(T value) throws IOException {Buffer buffer = new Buffer();Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);JsonWriter jsonWriter = gson.newJsonWriter(writer);adapter.write(jsonWriter, value);jsonWriter.close();return RequestBody.create(MEDIA_TYPE, buffer.readByteString());}
}

// 自定义TypeConverter类
public class Converters {private static Gson gson = new Gson();// 将List<String>转换为JSON字符串@TypeConverterpublic static String fromStringList(List<String> list) {return gson.toJson(list);}// 将JSON字符串转换为List<String>@TypeConverterpublic static List<String> toStringList(String json) {Type type = new TypeToken<List<String>>() {}.getType();return gson.fromJson(json, type);}// 将自定义对象转换为JSON字符串@TypeConverterpublic static String fromUser(User user) {return gson.toJson(user);}// 将JSON字符串转换为自定义对象@TypeConverterpublic static User toUser(String json) {return gson.fromJson(json, User.class);}
}// 在Room数据库中注册TypeConverter
@Database(entities = {Note.class}, version = 1)
@TypeConverters(Converters.class)
public abstract class AppDatabase extends RoomDatabase {public abstract NoteDao noteDao();
}

// 自定义TypeAdapterFactory
public class CustomTypeAdapterFactory implements TypeAdapterFactory {@Overridepublic <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {// 处理特定类型if (type.getRawType() == Date.class) {return (TypeAdapter<T>) new CustomDateTypeAdapter();}// 处理集合类型if (Collection.class.isAssignableFrom(type.getRawType())) {Type elementType = $Gson$Types.getCollectionElementType(type.getType(), type.getRawType());TypeAdapter<?> elementAdapter = gson.getAdapter(TypeToken.get(elementType));return (TypeAdapter<T>) new CustomCollectionTypeAdapter(gson, elementType, elementAdapter);}// 其他类型使用默认适配器return null;}
}// 自定义Date类型适配器
class CustomDateTypeAdapter extends TypeAdapter<Date> {private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");@Overridepublic Date read(JsonReader in) throws IOException {String dateStr = in.nextString();try {return dateFormat.parse(dateStr);} catch (ParseException e) {throw new JsonSyntaxException(e);}}@Overridepublic void write(JsonWriter out, Date date) throws IOException {if (date == null) {out.nullValue();return;}out.value(dateFormat.format(date));}
}// 自定义集合类型适配器
class CustomCollectionTypeAdapter<E> extends TypeAdapter<Collection<E>> {private final TypeAdapter<E> elementAdapter;public CustomCollectionTypeAdapter(Gson gson, Type elementType, TypeAdapter<E> elementAdapter) {this.elementAdapter = elementAdapter;}@Overridepublic Collection<E> read(JsonReader in) throws IOException {if (in.peek() == JsonToken.NULL) {in.nextNull();return null;}Collection<E> collection = new ArrayList<>();in.beginArray();while (in.hasNext()) {E element = elementAdapter.read(in);collection.add(element);}in.endArray();return collection;}@Overridepublic void write(JsonWriter out, Collection<E> collection) throws IOException {if (collection == null) {out.nullValue();return;}out.beginArray();for (E element : collection) {elementAdapter.write(out, element);}out.endArray();}
}

// 方法一：使用@Expose注解排除循环引用字段
public class Parent {private String name;@Expose(serialize = false, deserialize = false)private Child child;// getter和setter方法
}public class Child {private String name;@Expose(serialize = false, deserialize = false)private Parent parent;// getter和setter方法
}// 方法二：自定义TypeAdapter处理循环引用
public class ParentTypeAdapter extends TypeAdapter<Parent> {private final Map<Parent, Boolean> serialized = new IdentityHashMap<>();@Overridepublic void write(JsonWriter out, Parent parent) throws IOException {if (parent == null) {out.nullValue();return;}// 检查是否已序列化，避免循环引用if (serialized.containsKey(parent)) {out.beginObject();out.name("id").value(System.identityHashCode(parent));out.endObject();return;}// 标记为已序列化serialized.put(parent, true);out.beginObject();out.name("name").value(parent.getName());// 递归序列化child，但不处理其parent字段out.name("child");new ChildTypeAdapter(serialized).write(out, parent.getChild());out.endObject();}@Overridepublic Parent read(JsonReader in) throws IOException {// 反序列化实现...}
}public class ChildTypeAdapter extends TypeAdapter<Child> {private final Map<Parent, Boolean> serialized;public ChildTypeAdapter(Map<Parent, Boolean> serialized) {this.serialized = serialized;}@Overridepublic void write(JsonWriter out, Child child) throws IOException {if (child == null) {out.nullValue();return;}out.beginObject();out.name("name").value(child.getName());// 不序列化parent字段，避免循环引用// out.name("parent");// parentTypeAdapter.write(out, child.getParent());out.endObject();}@Overridepublic Child read(JsonReader in) throws IOException {// 反序列化实现...}
}

// 错误的方式（无法正确反序列化泛型类型）
List<String> list = gson.fromJson(json, List.class); // 会丢失泛型信息// 正确的方式（使用TypeToken保留泛型信息）
TypeToken<List<String>> typeToken = new TypeToken<List<String>>() {};
List<String> list = gson.fromJson(json, typeToken.getType());// 处理复杂泛型类型
TypeToken<Map<String, List<Integer>>> typeToken = new TypeToken<Map<String, List<Integer>>>() {};
Map<String, List<Integer>> map = gson.fromJson(json, typeToken.getType());// 在方法中使用TypeToken
public <T> T fromJson(String json, TypeToken<T> typeToken) {return gson.fromJson(json, typeToken.getType());
}// 使用示例
List<String> list = fromJson(json, new TypeToken<List<String>>() {});

// 基类
public abstract class Shape {private String type;public Shape(String type) {this.type = type;}public String getType() {return type;}// 抽象方法public abstract double area();
}// 子类
public class Circle extends Shape {private double radius;public Circle(double radius) {super("circle");this.radius = radius;}@Overridepublic double area() {return Math.PI * radius * radius;}public double getRadius() {return radius;}
}public class Rectangle extends Shape {private double width;private double height;public Rectangle(double width, double height) {super("rectangle");this.width = width;this.height = height;}@Overridepublic double area() {return width * height;}public double getWidth() {return width;}public double getHeight() {return height;}
}// 自定义TypeAdapter处理多态类型
public class ShapeTypeAdapter extends TypeAdapter<Shape> {private static final String TYPE_FIELD = "type";@Overridepublic void write(JsonWriter out, Shape shape) throws IOException {if (shape == null) {out.nullValue();return;}out.beginObject();out.name(TYPE_FIELD).value(shape.getType());if (shape instanceof Circle) {Circle circle = (Circle) shape;out.name("radius").value(circle.getRadius());} else if (shape instanceof Rectangle) {Rectangle rectangle = (Rectangle) shape;out.name("width").value(rectangle.getWidth());out.name("height").value(rectangle.getHeight());}out.endObject();}@Overridepublic Shape read(JsonReader in) throws IOException {if (in.peek() == JsonToken.NULL) {in.nextNull();return null;}String type = null;double radius = 0;double width = 0;double height = 0;in.beginObject();while (in.hasNext()) {String name = in.nextName();switch (name) {case TYPE_FIELD:type = in.nextString();break;case "radius":radius = in.nextDouble();break;case "width":width = in.nextDouble();break;case "height":height = in.nextDouble();break;default:in.skipValue();}}in.endObject();if ("circle".equals(type)) {return new Circle(radius);} else if ("rectangle".equals(type)) {return new Rectangle(width, height);} else {throw new JsonSyntaxException("Unknown shape type: " + type);}}
}// 注册自定义TypeAdapter
Gson gson = new GsonBuilder().registerTypeAdapter(Shape.class, new ShapeTypeAdapter()).create();// 使用示例
Shape circle = new Circle(5.0);
String json = gson.toJson(circle);Shape shape = gson.fromJson(json, Shape.class);
System.out.println("Area: " + shape.area());

public class GsonUtils {private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();public static Gson getInstance() {return GSON;}
}

class UserTypeAdapter extends TypeAdapter<User> {@Overridepublic void write(JsonWriter out, User user) throws IOException {out.beginObject();out.name("name").value(user.getName());out.name("age").value(user.getAge());out.endObject();}@Overridepublic User read(JsonReader in) throws IOException {String name = null;int age = 0;in.beginObject();while (in.hasNext()) {String jsonName = in.nextName();switch (jsonName) {case "name":name = in.nextString();break;case "age":age = in.nextInt();break;default:in.skipValue();}}in.endObject();return new User(name, age);}
}

public class User {private String name;private int age;@Expose(serialize = false)private String password;// getter和setter方法
}// 配置Gson只处理带@Expose注解的字段
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

// 读取大型JSON文件
try (JsonReader reader = new JsonReader(new FileReader("large_data.json"))) {reader.beginArray();while (reader.hasNext()) {// 逐行处理JSON元素processElement(reader);}reader.endArray();
} catch (IOException e) {e.printStackTrace();
}

android {compileOptions {sourceCompatibility JavaVersion.VERSION_1_8targetCompatibility JavaVersion.VERSION_1_8}
}