最近了解到使用json字符串存到数据库的一种存储方式，取出来的json字符串可以进行相应的节点操作

故借此机会练习下递归，完成对json节点操作对应的工具类。

介绍一下我使用的依赖

  1. 　　　　 <!-- fastjson -->
  2.         <dependency>
  3.             <groupId>com.alibaba</groupId>
  4.             <artifactId>fastjson</artifactId>
  5.             <version>1.2.49</version>
  6.         </dependency>

主要使用JSONObject和JSONArray的API进行相关操作，这里附上这两个类的代码

  1. /*
  2.  * Copyright 1999-2017 Alibaba Group.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package com.alibaba.fastjson;
  18. import static com.alibaba.fastjson.util.TypeUtils.castToBigDecimal;
  19. import static com.alibaba.fastjson.util.TypeUtils.castToBigInteger;
  20. import static com.alibaba.fastjson.util.TypeUtils.castToBoolean;
  21. import static com.alibaba.fastjson.util.TypeUtils.castToByte;
  22. import static com.alibaba.fastjson.util.TypeUtils.castToBytes;
  23. import static com.alibaba.fastjson.util.TypeUtils.castToDate;
  24. import static com.alibaba.fastjson.util.TypeUtils.castToDouble;
  25. import static com.alibaba.fastjson.util.TypeUtils.castToFloat;
  26. import static com.alibaba.fastjson.util.TypeUtils.castToInt;
  27. import static com.alibaba.fastjson.util.TypeUtils.castToLong;
  28. import static com.alibaba.fastjson.util.TypeUtils.castToShort;
  29. import static com.alibaba.fastjson.util.TypeUtils.castToSqlDate;
  30. import static com.alibaba.fastjson.util.TypeUtils.castToTimestamp;
  32. import java.io.*;
  33. import java.lang.reflect.Field;
  34. import java.lang.reflect.InvocationHandler;
  35. import java.lang.reflect.Method;
  36. import java.lang.reflect.Type;
  37. import java.math.BigDecimal;
  38. import java.math.BigInteger;
  39. import java.util.Collection;
  40. import java.util.Date;
  41. import java.util.HashMap;
  42. import java.util.LinkedHashMap;
  43. import java.util.Map;
  44. import java.util.Set;
  46. import com.alibaba.fastjson.annotation.JSONField;
  47. import com.alibaba.fastjson.parser.ParserConfig;
  48. import com.alibaba.fastjson.util.TypeUtils;
  50. /**
  51.  * @author wenshao[szujobs@hotmail.com]
  52.  */
  53. public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
  55.     private static final long         serialVersionUID         = 1L;
  56.     private static final int          DEFAULT_INITIAL_CAPACITY = 16;
  58.     private final Map<String, Object> map;
  60.     public JSONObject(){
  61.         this(DEFAULT_INITIAL_CAPACITY, false);
  62.     }
  64.     public JSONObject(Map<String, Object> map){
  65.         if (map == null) {
  66.             throw new IllegalArgumentException("map is null.");
  67.         }
  68.         this.map = map;
  69.     }
  71.     public JSONObject(boolean ordered){
  72.         this(DEFAULT_INITIAL_CAPACITY, ordered);
  73.     }
  75.     public JSONObject(int initialCapacity){
  76.         this(initialCapacity, false);
  77.     }
  79.     public JSONObject(int initialCapacity, boolean ordered){
  80.         if (ordered) {
  81.             map = new LinkedHashMap<String, Object>(initialCapacity);
  82.         } else {
  83.             map = new HashMap<String, Object>(initialCapacity);
  84.         }
  85.     }
  87.     public int size() {
  88.         return map.size();
  89.     }
  91.     public boolean isEmpty() {
  92.         return map.isEmpty();
  93.     }
  95.     public boolean containsKey(Object key) {
  96.         return map.containsKey(key);
  97.     }
  99.     public boolean containsValue(Object value) {
  100.         return map.containsValue(value);
  101.     }
  103.     public Object get(Object key) {
  104.         Object val = map.get(key);
  106.         if (val == null && key instanceof Number) {
  107.             val = map.get(key.toString());
  108.         }
  110.         return val;
  111.     }
  113.     public JSONObject getJSONObject(String key) {
  114.         Object value = map.get(key);
  116.         if (value instanceof JSONObject) {
  117.             return (JSONObject) value;
  118.         }
  120.         if (value instanceof String) {
  121.             return JSON.parseObject((String) value);
  122.         }
  124.         return (JSONObject) toJSON(value);
  125.     }
  127.     public JSONArray getJSONArray(String key) {
  128.         Object value = map.get(key);
  130.         if (value instanceof JSONArray) {
  131.             return (JSONArray) value;
  132.         }
  134.         if (value instanceof String) {
  135.             return (JSONArray) JSON.parse((String) value);
  136.         }
  138.         return (JSONArray) toJSON(value);
  139.     }
  141.     public <T> T getObject(String key, Class<T> clazz) {
  142.         Object obj = map.get(key);
  143.         return TypeUtils.castToJavaBean(obj, clazz);
  144.     }
  146.     public <T> T getObject(String key, Type type) {
  147.         Object obj = map.get(key);
  148.         return TypeUtils.cast(obj, type, ParserConfig.getGlobalInstance());
  149.     }
  151.     public <T> T getObject(String key, TypeReference typeReference) {
  152.         Object obj = map.get(key);
  153.         if (typeReference == null) {
  154.             return (T) obj;
  155.         }
  156.         return TypeUtils.cast(obj, typeReference.getType(), ParserConfig.getGlobalInstance());
  157.     }
  159.     public Boolean getBoolean(String key) {
  160.         Object value = get(key);
  162.         if (value == null) {
  163.             return null;
  164.         }
  166.         return castToBoolean(value);
  167.     }
  169.     public byte[] getBytes(String key) {
  170.         Object value = get(key);
  172.         if (value == null) {
  173.             return null;
  174.         }
  176.         return castToBytes(value);
  177.     }
  179.     public boolean getBooleanValue(String key) {
  180.         Object value = get(key);
  182.         Boolean booleanVal = castToBoolean(value);
  183.         if (booleanVal == null) {
  184.             return false;
  185.         }
  187.         return booleanVal.booleanValue();
  188.     }
  190.     public Byte getByte(String key) {
  191.         Object value = get(key);
  193.         return castToByte(value);
  194.     }
  196.     public byte getByteValue(String key) {
  197.         Object value = get(key);
  199.         Byte byteVal = castToByte(value);
  200.         if (byteVal == null) {
  201.             return 0;
  202.         }
  204.         return byteVal.byteValue();
  205.     }
  207.     public Short getShort(String key) {
  208.         Object value = get(key);
  210.         return castToShort(value);
  211.     }
  213.     public short getShortValue(String key) {
  214.         Object value = get(key);
  216.         Short shortVal = castToShort(value);
  217.         if (shortVal == null) {
  218.             return 0;
  219.         }
  221.         return shortVal.shortValue();
  222.     }
  224.     public Integer getInteger(String key) {
  225.         Object value = get(key);
  227.         return castToInt(value);
  228.     }
  230.     public int getIntValue(String key) {
  231.         Object value = get(key);
  233.         Integer intVal = castToInt(value);
  234.         if (intVal == null) {
  235.             return 0;
  236.         }
  238.         return intVal.intValue();
  239.     }
  241.     public Long getLong(String key) {
  242.         Object value = get(key);
  244.         return castToLong(value);
  245.     }
  247.     public long getLongValue(String key) {
  248.         Object value = get(key);
  250.         Long longVal = castToLong(value);
  251.         if (longVal == null) {
  252.             return 0L;
  253.         }
  255.         return longVal.longValue();
  256.     }
  258.     public Float getFloat(String key) {
  259.         Object value = get(key);
  261.         return castToFloat(value);
  262.     }
  264.     public float getFloatValue(String key) {
  265.         Object value = get(key);
  267.         Float floatValue = castToFloat(value);
  268.         if (floatValue == null) {
  269.             return 0F;
  270.         }
  272.         return floatValue.floatValue();
  273.     }
  275.     public Double getDouble(String key) {
  276.         Object value = get(key);
  278.         return castToDouble(value);
  279.     }
  281.     public double getDoubleValue(String key) {
  282.         Object value = get(key);
  284.         Double doubleValue = castToDouble(value);
  285.         if (doubleValue == null) {
  286.             return 0D;
  287.         }
  289.         return doubleValue.doubleValue();
  290.     }
  292.     public BigDecimal getBigDecimal(String key) {
  293.         Object value = get(key);
  295.         return castToBigDecimal(value);
  296.     }
  298.     public BigInteger getBigInteger(String key) {
  299.         Object value = get(key);
  301.         return castToBigInteger(value);
  302.     }
  304.     public String getString(String key) {
  305.         Object value = get(key);
  307.         if (value == null) {
  308.             return null;
  309.         }
  311.         return value.toString();
  312.     }
  314.     public Date getDate(String key) {
  315.         Object value = get(key);
  317.         return castToDate(value);
  318.     }
  320.     public java.sql.Date getSqlDate(String key) {
  321.         Object value = get(key);
  323.         return castToSqlDate(value);
  324.     }
  326.     public java.sql.Timestamp getTimestamp(String key) {
  327.         Object value = get(key);
  329.         return castToTimestamp(value);
  330.     }
  331.     
  332.     public Object put(String key, Object value) {
  333.         return map.put(key, value);
  334.     }
  335.     
  336.     public JSONObject fluentPut(String key, Object value) {
  337.         map.put(key, value);
  338.         return this;
  339.     }
  341.     public void putAll(Map<? extends String, ? extends Object> m) {
  342.         map.putAll(m);
  343.     }
  345.     public JSONObject fluentPutAll(Map<? extends String, ? extends Object> m) {
  346.         map.putAll(m);
  347.         return this;
  348.     }
  350.     public void clear() {
  351.         map.clear();
  352.     }
  354.     public JSONObject fluentClear() {
  355.         map.clear();
  356.         return this;
  357.     }
  359.     public Object remove(Object key) {
  360.         return map.remove(key);
  361.     }
  363.     public JSONObject fluentRemove(Object key) {
  364.         map.remove(key);
  365.         return this;
  366.     }
  368.     public Set<String> keySet() {
  369.         return map.keySet();
  370.     }
  372.     public Collection<Object> values() {
  373.         return map.values();
  374.     }
  376.     public Set<Map.Entry<String, Object>> entrySet() {
  377.         return map.entrySet();
  378.     }
  380.     @Override
  381.     public Object clone() {
  382.         return new JSONObject(map instanceof LinkedHashMap //
  383.                               ? new LinkedHashMap<String, Object>(map) //
  384.                                   : new HashMap<String, Object>(map)
  385.                                   );
  386.     }
  388.     public boolean equals(Object obj) {
  389.         return this.map.equals(obj);
  390.     }
  392.     public int hashCode() {
  393.         return this.map.hashCode();
  394.     }
  396.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  397.         Class<?>[] parameterTypes = method.getParameterTypes();
  398.         if (parameterTypes.length == 1) {
  399.             if (method.getName().equals("equals")) {
  400.                 return this.equals(args[0]);
  401.             }
  402.             
  403.             Class<?> returnType = method.getReturnType();
  404.             if (returnType != void.class) {
  405.                 throw new JSONException("illegal setter");
  406.             }
  408.             String name = null;
  409.             JSONField annotation = method.getAnnotation(JSONField.class);
  410.             if (annotation != null) {
  411.                 if (annotation.name().length() != 0) {
  412.                     name = annotation.name();
  413.                 }
  414.             }
  416.             if (name == null) {
  417.                 name = method.getName();
  418.                 
  419.                 if (!name.startsWith("set")) {
  420.                     throw new JSONException("illegal setter");
  421.                 }
  423.                 name = name.substring(3);
  424.                 if (name.length() == 0) {
  425.                     throw new JSONException("illegal setter");
  426.                 }
  427.                 name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
  428.             }
  430.             map.put(name, args[0]);
  431.             return null;
  432.         }
  434.         if (parameterTypes.length == 0) {
  435.             Class<?> returnType = method.getReturnType();
  436.             if (returnType == void.class) {
  437.                 throw new JSONException("illegal getter");
  438.             }
  440.             String name = null;
  441.             JSONField annotation = method.getAnnotation(JSONField.class);
  442.             if (annotation != null) {
  443.                 if (annotation.name().length() != 0) {
  444.                     name = annotation.name();
  445.                 }
  446.             }
  448.             if (name == null) {
  449.                 name = method.getName();
  450.                 if (name.startsWith("get")) {
  451.                     name = name.substring(3);
  452.                     if (name.length() == 0) {
  453.                         throw new JSONException("illegal getter");
  454.                     }
  455.                     name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
  456.                 } else if (name.startsWith("is")) {
  457.                     name = name.substring(2);
  458.                     if (name.length() == 0) {
  459.                         throw new JSONException("illegal getter");
  460.                     }
  461.                     name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
  462.                 } else if (name.startsWith("hashCode")) {
  463.                     return this.hashCode();
  464.                 } else if (name.startsWith("toString")) {
  465.                     return this.toString();
  466.                 } else {
  467.                     throw new JSONException("illegal getter");
  468.                 }
  469.             }
  470.             
  471.             Object value = map.get(name);
  472.             return TypeUtils.cast(value, method.getGenericReturnType(), ParserConfig.getGlobalInstance());
  473.         }
  475.         throw new UnsupportedOperationException(method.toGenericString());
  476.     }
  478.     public Map<String, Object> getInnerMap() {
  479.         return this.map;
  480.     }
  484.     private void readObject(final java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
  485.         SecureObjectInputStream.ensureFields();
  486.         if (SecureObjectInputStream.fields != null && !SecureObjectInputStream.fields_error) {
  487.             ObjectInputStream secIn = new SecureObjectInputStream(in);
  488.             secIn.defaultReadObject();
  489.             return;
  490.         }
  492.         in.defaultReadObject();
  493.         for (Entry entry : map.entrySet()) {
  494.             final Object key = entry.getKey();
  495.             if (key != null) {
  496.                 ParserConfig.global.checkAutoType(key.getClass().getName(), null);
  497.             }
  499.             final Object value = entry.getValue();
  500.             if (value != null) {
  501.                 ParserConfig.global.checkAutoType(value.getClass().getName(), null);
  502.             }
  503.         }
  504.     }
  506.     static class SecureObjectInputStream extends ObjectInputStream {
  507.         static Field[] fields;
  508.         static volatile boolean fields_error;
  510.         static void ensureFields() {
  511.             if (fields == null && !fields_error) {
  512.                 try {
  513.                     final Field[] declaredFields = ObjectInputStream.class.getDeclaredFields();
  514.                     String[] fieldnames = new String[]{"bin", "passHandle", "handles", "curContext"};
  515.                     Field[] array = new Field[fieldnames.length];
  516.                     for (int i = 0; i < fieldnames.length; i++) {
  517.                         Field field = TypeUtils
  518.                                 .getField(ObjectInputStream.class
  519.                                         , fieldnames[i]
  520.                                         , declaredFields
  521.                                 );
  522.                         field.setAccessible(true);
  523.                         array[i] = field;
  524.                     }
  525.                     fields = array;
  526.                 } catch (Throwable error) {
  527.                     fields_error = true;
  528.                 }
  529.             }
  530.         }
  532.         public SecureObjectInputStream(ObjectInputStream in) throws IOException {
  533.             super(in);
  534.             try {
  535.                 for (int i = 0; i < fields.length; i++) {
  536.                     final Field field = fields[i];
  537.                     final Object value = field.get(in);
  538.                     field.set(this, value);
  539.                 }
  540.             } catch (IllegalAccessException e) {
  541.                 fields_error = true;
  542.             }
  543.         }
  545.         protected Class<?> resolveClass(ObjectStreamClass desc)
  546.         throws IOException, ClassNotFoundException {
  547.             String name = desc.getName();
  548.             ParserConfig.global.checkAutoType(name, null);
  549.             return super.resolveClass(desc);
  550.         }
  552.         protected Class<?> resolveProxyClass(String[] interfaces)
  553.         throws IOException, ClassNotFoundException {
  554.             for (String interfacename : interfaces) {
  555.                 //检查是否处于黑名单
  556.                 ParserConfig.global.checkAutoType(interfacename, null);
  557.             }
  558.             return super.resolveProxyClass(interfaces);
  559.         }
  561.         //Hack:默认构造方法会调用这个方法，重写此方法使用反射还原部分关键属性
  562.         protected void readStreamHeader() throws IOException, StreamCorruptedException {
  564.         }
  565.     }
  566. }

JSONObject 

  1. /*
  2.  * Copyright 1999-2017 Alibaba Group.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package com.alibaba.fastjson;
  18. import static com.alibaba.fastjson.util.TypeUtils.castToBigDecimal;
  19. import static com.alibaba.fastjson.util.TypeUtils.castToBigInteger;
  20. import static com.alibaba.fastjson.util.TypeUtils.castToBoolean;
  21. import static com.alibaba.fastjson.util.TypeUtils.castToByte;
  22. import static com.alibaba.fastjson.util.TypeUtils.castToDate;
  23. import static com.alibaba.fastjson.util.TypeUtils.castToDouble;
  24. import static com.alibaba.fastjson.util.TypeUtils.castToFloat;
  25. import static com.alibaba.fastjson.util.TypeUtils.castToInt;
  26. import static com.alibaba.fastjson.util.TypeUtils.castToLong;
  27. import static com.alibaba.fastjson.util.TypeUtils.castToShort;
  28. import static com.alibaba.fastjson.util.TypeUtils.castToSqlDate;
  29. import static com.alibaba.fastjson.util.TypeUtils.castToString;
  30. import static com.alibaba.fastjson.util.TypeUtils.castToTimestamp;
  32. import java.io.IOException;
  33. import java.io.ObjectInputStream;
  34. import java.io.Serializable;
  35. import java.lang.reflect.Type;
  36. import java.math.BigDecimal;
  37. import java.math.BigInteger;
  38. import java.util.*;
  40. import com.alibaba.fastjson.parser.ParserConfig;
  41. import com.alibaba.fastjson.parser.deserializer.ObjectDeserializer;
  42. import com.alibaba.fastjson.util.TypeUtils;
  44. /**
  45.  * @author wenshao[szujobs@hotmail.com]
  46.  */
  47. public class JSONArray extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable {
  49.     private static final long  serialVersionUID = 1L;
  50.     private final List<Object> list;
  51.     protected transient Object relatedArray;
  52.     protected transient Type   componentType;
  54.     public JSONArray(){
  55.         this.list = new ArrayList<Object>();
  56.     }
  58.     public JSONArray(List<Object> list){
  59.         this.list = list;
  60.     }
  62.     public JSONArray(int initialCapacity){
  63.         this.list = new ArrayList<Object>(initialCapacity);
  64.     }
  66.     /**
  67.      * @since 1.1.16
  68.      * @return
  69.      */
  70.     public Object getRelatedArray() {
  71.         return relatedArray;
  72.     }
  74.     public void setRelatedArray(Object relatedArray) {
  75.         this.relatedArray = relatedArray;
  76.     }
  78.     public Type getComponentType() {
  79.         return componentType;
  80.     }
  82.     public void setComponentType(Type componentType) {
  83.         this.componentType = componentType;
  84.     }
  86.     public int size() {
  87.         return list.size();
  88.     }
  90.     public boolean isEmpty() {
  91.         return list.isEmpty();
  92.     }
  94.     public boolean contains(Object o) {
  95.         return list.contains(o);
  96.     }
  98.     public Iterator<Object> iterator() {
  99.         return list.iterator();
  100.     }
  102.     public Object[] toArray() {
  103.         return list.toArray();
  104.     }
  106.     public <T> T[] toArray(T[] a) {
  107.         return list.toArray(a);
  108.     }
  110.     public boolean add(Object e) {
  111.         return list.add(e);
  112.     }
  114.     public JSONArray fluentAdd(Object e) {
  115.         list.add(e);
  116.         return this;
  117.     }
  119.     public boolean remove(Object o) {
  120.         return list.remove(o);
  121.     }
  123.     public JSONArray fluentRemove(Object o) {
  124.         list.remove(o);
  125.         return this;
  126.     }
  128.     public boolean containsAll(Collection<?> c) {
  129.         return list.containsAll(c);
  130.     }
  132.     public boolean addAll(Collection<? extends Object> c) {
  133.         return list.addAll(c);
  134.     }
  136.     public JSONArray fluentAddAll(Collection<? extends Object> c) {
  137.         list.addAll(c);
  138.         return this;
  139.     }
  141.     public boolean addAll(int index, Collection<? extends Object> c) {
  142.         return list.addAll(index, c);
  143.     }
  145.     public JSONArray fluentAddAll(int index, Collection<? extends Object> c) {
  146.         list.addAll(index, c);
  147.         return this;
  148.     }
  150.     public boolean removeAll(Collection<?> c) {
  151.         return list.removeAll(c);
  152.     }
  154.     public JSONArray fluentRemoveAll(Collection<?> c) {
  155.         list.removeAll(c);
  156.         return this;
  157.     }
  159.     public boolean retainAll(Collection<?> c) {
  160.         return list.retainAll(c);
  161.     }
  163.     public JSONArray fluentRetainAll(Collection<?> c) {
  164.         list.retainAll(c);
  165.         return this;
  166.     }
  168.     public void clear() {
  169.         list.clear();
  170.     }
  172.     public JSONArray fluentClear() {
  173.         list.clear();
  174.         return this;
  175.     }
  177.     public Object set(int index, Object element) {
  178.         if (index == -1) {
  179.             list.add(element);
  180.             return null;
  181.         }
  182.         
  183.         if (list.size() <= index) {
  184.             for (int i = list.size(); i < index; ++i) {
  185.                 list.add(null);
  186.             }
  187.             list.add(element);
  188.             return null;
  189.         }
  190.         
  191.         return list.set(index, element);
  192.     }
  194.     public JSONArray fluentSet(int index, Object element) {
  195.         set(index, element);
  196.         return this;
  197.     }
  199.     public void add(int index, Object element) {
  200.         list.add(index, element);
  201.     }
  203.     public JSONArray fluentAdd(int index, Object element) {
  204.         list.add(index, element);
  205.         return this;
  206.     }
  208.     public Object remove(int index) {
  209.         return list.remove(index);
  210.     }
  212.     public JSONArray fluentRemove(int index) {
  213.         list.remove(index);
  214.         return this;
  215.     }
  217.     public int indexOf(Object o) {
  218.         return list.indexOf(o);
  219.     }
  221.     public int lastIndexOf(Object o) {
  222.         return list.lastIndexOf(o);
  223.     }
  225.     public ListIterator<Object> listIterator() {
  226.         return list.listIterator();
  227.     }
  229.     public ListIterator<Object> listIterator(int index) {
  230.         return list.listIterator(index);
  231.     }
  233.     public List<Object> subList(int fromIndex, int toIndex) {
  234.         return list.subList(fromIndex, toIndex);
  235.     }
  237.     public Object get(int index) {
  238.         return list.get(index);
  239.     }
  241.     public JSONObject getJSONObject(int index) {
  242.         Object value = list.get(index);
  244.         if (value instanceof JSONObject) {
  245.             return (JSONObject) value;
  246.         }
  248.         return (JSONObject) toJSON(value);
  249.     }
  251.     public JSONArray getJSONArray(int index) {
  252.         Object value = list.get(index);
  254.         if (value instanceof JSONArray) {
  255.             return (JSONArray) value;
  256.         }
  258.         return (JSONArray) toJSON(value);
  259.     }
  261.     public <T> T getObject(int index, Class<T> clazz) {
  262.         Object obj = list.get(index);
  263.         return TypeUtils.castToJavaBean(obj, clazz);
  264.     }
  266.     public <T> T getObject(int index, Type type) {
  267.         Object obj = list.get(index);
  268.         if (type instanceof Class) {
  269.             return (T) TypeUtils.castToJavaBean(obj, (Class) type);
  270.         } else {
  271.             String json = JSON.toJSONString(obj);
  272.             return (T) JSON.parseObject(json, type);
  273.         }
  274.     }
  276.     public Boolean getBoolean(int index) {
  277.         Object value = get(index);
  279.         if (value == null) {
  280.             return null;
  281.         }
  283.         return castToBoolean(value);
  284.     }
  286.     public boolean getBooleanValue(int index) {
  287.         Object value = get(index);
  289.         if (value == null) {
  290.             return false;
  291.         }
  293.         return castToBoolean(value).booleanValue();
  294.     }
  296.     public Byte getByte(int index) {
  297.         Object value = get(index);
  299.         return castToByte(value);
  300.     }
  302.     public byte getByteValue(int index) {
  303.         Object value = get(index);
  305.         if (value == null) {
  306.             return 0;
  307.         }
  309.         return castToByte(value).byteValue();
  310.     }
  312.     public Short getShort(int index) {
  313.         Object value = get(index);
  315.         return castToShort(value);
  316.     }
  318.     public short getShortValue(int index) {
  319.         Object value = get(index);
  321.         if (value == null) {
  322.             return 0;
  323.         }
  325.         return castToShort(value).shortValue();
  326.     }
  328.     public Integer getInteger(int index) {
  329.         Object value = get(index);
  331.         return castToInt(value);
  332.     }
  334.     public int getIntValue(int index) {
  335.         Object value = get(index);
  337.         if (value == null) {
  338.             return 0;
  339.         }
  341.         return castToInt(value).intValue();
  342.     }
  344.     public Long getLong(int index) {
  345.         Object value = get(index);
  347.         return castToLong(value);
  348.     }
  350.     public long getLongValue(int index) {
  351.         Object value = get(index);
  353.         if (value == null) {
  354.             return 0L;
  355.         }
  357.         return castToLong(value).longValue();
  358.     }
  360.     public Float getFloat(int index) {
  361.         Object value = get(index);
  363.         return castToFloat(value);
  364.     }
  366.     public float getFloatValue(int index) {
  367.         Object value = get(index);
  369.         if (value == null) {
  370.             return 0F;
  371.         }
  373.         return castToFloat(value).floatValue();
  374.     }
  376.     public Double getDouble(int index) {
  377.         Object value = get(index);
  379.         return castToDouble(value);
  380.     }
  382.     public double getDoubleValue(int index) {
  383.         Object value = get(index);
  385.         if (value == null) {
  386.             return 0D;
  387.         }
  389.         return castToDouble(value);
  390.     }
  392.     public BigDecimal getBigDecimal(int index) {
  393.         Object value = get(index);
  395.         return castToBigDecimal(value);
  396.     }
  398.     public BigInteger getBigInteger(int index) {
  399.         Object value = get(index);
  401.         return castToBigInteger(value);
  402.     }
  404.     public String getString(int index) {
  405.         Object value = get(index);
  407.         return castToString(value);
  408.     }
  410.     public java.util.Date getDate(int index) {
  411.         Object value = get(index);
  413.         return castToDate(value);
  414.     }
  416.     public java.sql.Date getSqlDate(int index) {
  417.         Object value = get(index);
  419.         return castToSqlDate(value);
  420.     }
  422.     public java.sql.Timestamp getTimestamp(int index) {
  423.         Object value = get(index);
  425.         return castToTimestamp(value);
  426.     }
  428.     /**
  429.      * @since  1.2.23
  430.      */
  431.     public <T> List<T> toJavaList(Class<T> clazz) {
  432.         List<T> list = new ArrayList<T>(this.size());
  434.         ParserConfig config = ParserConfig.getGlobalInstance();
  436.         for (Object item : this) {
  437.             T classItem = (T) TypeUtils.cast(item, clazz, config);
  438.             list.add(classItem);
  439.         }
  441.         return list;
  442.     }
  444.     @Override
  445.     public Object clone() {
  446.         return new JSONArray(new ArrayList<Object>(list));
  447.     }
  449.     public boolean equals(Object obj) {
  450.         return this.list.equals(obj);
  451.     }
  453.     public int hashCode() {
  454.         return this.list.hashCode();
  455.     }
  457.     private void readObject(final java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
  458.         JSONObject.SecureObjectInputStream.ensureFields();
  459.         if (JSONObject.SecureObjectInputStream.fields != null && !JSONObject.SecureObjectInputStream.fields_error) {
  460.             ObjectInputStream secIn = new JSONObject.SecureObjectInputStream(in);
  461.             secIn.defaultReadObject();
  462.             return;
  463.         }
  465.         in.defaultReadObject();
  466.         for (Object item : list) {
  467.             if (item != null) {
  468.                 ParserConfig.global.checkAutoType(item.getClass().getName(), null);
  469.             }
  470.         }
  471.     }
  472. }

JSONArray

一些数据转换的API

JSONArray.parseArray(“json树字符串”)———–可以返回JSONArray对象

jsonArray对象.toJSONString()————————可以转换为字符串便于存入数据库

 

首先我们需要有一个json树，这里可以自己编写，跟数据库操作的相关方法暂不涉及，这里直接使用相关API搭建，在main方法中

  1.     public static void main(String[] args) {
  2.         JSONArray details=new JSONArray();
  3.         JSONObject tree1=new JSONObject();
  4.         tree1.put("id",1);
  5.         tree1.put("code", "taosir");
  6.         tree1.put("name", "taosir");
  7.         JSONObject tree2=new JSONObject();
  8.         tree2.put("id",2);
  9.         tree2.put("code", "moer");
  10.         tree2.put("name", "moer");
  11.         JSONArray array1=new JSONArray();
  12.         array1.add(tree1);
  13.         array1.add(tree2);
  14.         JSONObject tree3=new JSONObject();
  15.         tree3.put("id",3);
  16.         tree3.put("code", "xixi");
  17.         tree3.put("name", "xixi");
  18.         tree3.put("children", array1);
  19.         JSONObject tree4=new JSONObject();
  20.         tree4.put("id",4);
  21.         tree4.put("code", "jack");
  22.         tree4.put("name", "jack");
  23.         JSONArray array2=new JSONArray();
  24.         array2.add(tree3);
  25.         array2.add(tree4);
  26.         JSONObject tree5=new JSONObject();
  27.         tree5.put("id",5);
  28.         tree5.put("code", "lay");
  29.         tree5.put("name", "lay");
  30.         tree5.put("children", array2);
  31.         JSONObject tree6=new JSONObject();
  32.         tree6.put("id",6);
  33.         tree6.put("code", "haer");
  34.         tree6.put("name", "haer");
  35.         details.add(tree5);
  36.         details.add(tree6);
  37.         System.out.println(details);
  38.     }

[{
    "id":5,
    "code":"lay",
    "name":"lay",
    "children":[{
        "id":3,
        "code":"xixi",
        "name":"xixi",
        "children":[{
            "code":"taosir",
            "name":"taosir",
            "id":1
        },{
            "code":"moer",
            "name":"moer",
            "id":2
        }]
    },{
        "id":4
        "code":"jack",
        "name":"jack"
    }]
},{
    "code":"haer",
    "name":"haer",
    "id":6
}]

生成的json树

点击上面可以查看生成的json树

OK，准备工作完毕，下面进行功能演示。

（注意，每演示一个功能点，请注释掉其他的打印语句）

 

首先是查询：

/**
     * 根据单一条件获取节点位置
     * @param body            查询目标的主体内容
     * @param key            筛选匹配条件条件对应--key
     * @param value            筛选匹配条件对应--value
     * @param result        缓存查询结果
     * @return
     */
    public static JSONObject getNode(JSONArray body,String key,Object value,JSONObject result) {
        for (int i = 0; i < body.size(); i++) {
            JSONObject jsonObject =body.getJSONObject(i);
            if (jsonObject.get(key).toString().equals(value.toString())) {
                for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
                    result.put(entry.getKey(), entry.getValue());
                }
            }else if(jsonObject.getJSONArray("children")!=null) {
                getNode(jsonObject.getJSONArray("children"), key, value,result);
            }
        }
        return result;
    }

在main方法调用演示，将前面的打印注释掉

//System.out.println(details);
System.out.println(getNode(details, "id", 4,new JSONObject()));

 

查询写出来，基本思路对了，其他的操作都类似，简单得多

下面是添加

/**
     * 
     * @param body            需要添加的目标树主体
     * @param key            筛选匹配条件对应的key
     * @param value            筛选匹配条件的值
     * @param index            需要插入的下标位置索引
     * @param node            插入的整体节点
     */
    public static void addNode(JSONArray body,String key,Object value,int index,JSONObject node) {
        for (int i = 0; i < body.size(); i++) {
            if("id".equals(key)&&"0".equals(value.toString())) {
                body.add(index, node);
                break;
            }
            JSONObject jsonObject =body.getJSONObject(i);
            if (jsonObject.get(key).toString().equals(value.toString())) {
                jsonObject.getJSONArray("children").add(index, node);
            }else if(jsonObject.getJSONArray("children")!=null) {
                addNode(jsonObject.getJSONArray("children"), key, value,index,node);
            }
        }
    }
System.out.println(getNode(details, "id",6 ,new JSONObject()));
JSONObject tree7=new JSONObject();
tree7.put("id",7);
tree7.put("code", "bom");
tree7.put("name", "bom");
addNode(details, "id", 6, 0, tree7);
System.out.println(getNode(details, "id",6 ,new JSONObject()));

可以看到，当节点位置没有子节点时，默认追加，这个时候需要传0，没有考虑越界，可以弄自定义异常处理

System.out.println(getNode(details, "id",6 ,new JSONObject()));
JSONObject tree8=new JSONObject();
tree8.put("id",8);
tree8.put("code", "naonao");
tree8.put("name", "naonao");
addNode(details, "id", 6, 0, tree8);
System.out.println(getNode(details, "id",6 ,new JSONObject()));

这种是已经有节点的情况，可以看到为直接插入索引位置

 

下面是删除，不保留孩子节点：

    /**
     * 根据单一条件删除节点
     * @param body        需要删除的目标主体
     * @param key        筛选匹配条件对应的key
     * @param value        筛选匹配条件对应的value
     */
    public static void delNode(JSONArray body,String key,Object value) {
        for (int i = 0; i < body.size(); i++) {
            JSONObject jsonObject =body.getJSONObject(i);
            if (jsonObject.get(key).toString().equals(value.toString())) {
                body.remove(i);
                break;
            }else if(jsonObject.getJSONArray("children")!=null) {
                delNode(jsonObject.getJSONArray("children"), key, value);
            }
        }
    }
System.out.println(getNode(details, "id",6 ,new JSONObject()));
delNode(details, "id", 8);
System.out.println(getNode(details, "id",6 ,new JSONObject()));

可以看到刚才加入的节点（id=8）已经被成功删除

 

下面是修改，可以选择是否保留孩子节点

/**
     * 根据单一条件修改节点
     * @param body        需要修改的目标主体
     * @param key        筛选匹配条件对应的key
     * @param value        筛选匹配条件对应的value
     * @param result    修改节点信息
     * @param isKeep    是否保留孩子节点
     */
    public static void updateNode(JSONArray body,String key,Object value,JSONObject result,boolean isKeep) {
        for (int i = 0; i < body.size(); i++) {
            JSONObject jsonObject =body.getJSONObject(i);
            if (jsonObject.get(key).toString().equals(value.toString())) {
                if(isKeep)
                    result.put("children", jsonObject.getJSONArray("children"));
                body.set(i, result);
                break;
            }else if(jsonObject.getJSONArray("children")!=null) {
                updateNode(jsonObject.getJSONArray("children"), key, value,result,isKeep);
            }
        }
    }

当需要保留孩子节点时：

System.out.println(getNode(details, "id",6 ,new JSONObject()));
JSONObject tree9=new JSONObject();
tree9.put("id",6);
tree9.put("code", "bom");
tree9.put("name", "bom");
updateNode(details, "id", 6, tree9, true);
System.out.println(getNode(details, "id",6 ,new JSONObject()));

当不需要保留孩子节点时：

System.out.println(getNode(details, "id",6 ,new JSONObject()));
JSONObject tree9=new JSONObject();
tree9.put("id",6);
tree9.put("code", "bom");
tree9.put("name", "bom");
updateNode(details, "id", 6, tree9, false);
System.out.println(getNode(details, "id",6 ,new JSONObject()));

 

以上，为简单的增删查改，根据业务不同会有不同的更改。

虽然业务要求匹配ID即可，不过这里以单一条件的匹配，能正常实现也能应对需要匹配其他字段的情况

每个人的实现方式不同，这里仅是我个人的思路与实现，仅供参考。

新人一枚，如有疑问或建议，欢迎提出！

 

版权声明：本文为it-taosir原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/it-taosir/p/9860829.html