JSON資料及與其他各類資料轉換詳解

happyAliceYu發表於2017-03-23

一、JSON的標準格式

裡面的是一個物件，如果是多個物件，則用逗號間隔，即{},{}，這樣就組成了一個物件序列，為了辨別開始和結束，則需要加上[]才能進行傳遞，則實際傳遞的形式應該是[{},{}]，如果只要傳遞一個物件，則{}的形式就可以了。接下來就是物件屬性的表現方式了，屬性必須在”“裡面，屬性與值之間用:隔開，屬性之間用,來分隔，如果屬性的值為陣列，則用[]包括起來，這樣實際傳遞的資料格式可能有：1、{“屬性1”:值1,”屬性2”:值2}，如果值為字串，則也需要用”“括起來（下同）。2、{“屬性1”:值1,”屬性2”:[值1，值2]}，其中屬性2是一個陣列，包含了值1和值2。3、{“屬性1”:值1,”屬性2”:{“屬性a”:值a,”屬性b”:[值b，值c]}}，這個比較複雜了，屬性2是個物件，這個物件由包含屬性a和屬性b，屬性b又是一個陣列包含值b和值c。我想這些應該是最基本了，其餘的就是在此基礎上的擴充而已。

二、JSON與其他格式的互相轉化

【Java————->JSON】

/**
 *後臺怎麼拼裝JSON格式的字串
 */

public String javaToJSON() {
    JSONObject jsonObj = new JSONObject();
    jsonObj.put("username", "張三");
    jsonObj.put("password", "123456");
    return jsonObj.toString();//{"password", "123456","username", "張三"}
}

【JSON———–>XML】

/**
 *JSON格式的字串轉換成XML格式的字串
 */

public String jsonToXML() {
    String jsonStr = "{\"password\":\"123456\",\"username\":\"張三\"}";
    JSONObject json = JSONObject.fromString(jsonStr);
    XMLSerializer xmlSerializer = new XMLSerializer();
    xmlSerializer.setRootName("user_info");
    xmlSerializer.setTypeHintsEnabled(false);
    String xml = xmlSerializer.write(json);
    return xml;
}

返回結果；

<?xml version="1.0" encoding="utf-8"?>
<user_info>
    <password>123456</password>
    <username>劉夢冰</username>
</user_info>

【XML———–>JSON】

/**
 *XML格式的字串轉換成JSON格式的字串
 */
public String xmlToJSON(){
    String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><user_info><password>123456</password><username>張三</username></user_info>";
    JSON json=XMLSerializer.read(xml);
    return json.toString();
}

public mapToJSON(Map<Object,Object>map)
{
   return JSONObject.fromobject(map).tostring();
}

【Map ———->json:】

/**
* 將map集合轉換為json語句表示
*
* @param map 集合
* @return 得到的Map解析的json語句
*/
public String mapToJson(Map<Object, Object> map) {
    JSONObject jsonObject = JSONObject.fromObject(map);     //將集合解析為 json物件語句(net.sf.json.JSONObject)
    return jsonObject.toString();                              //返回json語句
}

【json————>Map:】

/** 
 * 將json格式封裝的字串資料轉換成java中的Map資料 
 * @return 
 */  
private Map<Object, Object> jsonToMap() { 
   String jsonStr = req.getParameter("User"); //以引數的形式接收前端傳過來的資料   Map<Object, Object> map = new HashMap<Object, Object>(); 
   JSONArray jsonArray = JSONArray.fromObject(jsonStr)；
   JSONObject jsonOne;
		for (int i=0;i<jsonArray.size();i++) {
			jsonOne = jsonArray.getJSONObject(i);
			map.put("username", (String) jsonOne.get("name"));
			map.put("age", jsonOne.getString("value"));
		}
	return map;   //這才完成JSON向Map資料結構的轉換，便於在後臺傳遞並處理。}

【JSON————->List】

/** 
 * 將json格式封裝的列表資料轉換成java的List資料 [net.sf.ezmorph.bean.MorphDynaBean@1eb605e7[
                                                {name=username, value=wwww}],...]
])
 * @return 
 */  
private static Object JSON2List(String json) {    
    return JSONArray.toList(JSONArray.fromObject(json));  
}

【JSON——->簡單JavaBean/複雜JavaBean】

/**
 * 只包含基本資料型別的簡單實體類(getter、setetr方法略)
 */
public class SimpleUser {

    private int id;

    private String name;

    private String sex;

    private int age;

    private String province;
}
/**
 * 包含複雜型別的實體類
 */
public class ComplexUser extends SimpleUser {

    private List<String> address;

    public ComplexUser() {
    }

    public ComplexUser(int id, String name,
            String sex, int age, String province,
            List<String> address) {
        super(id, name, sex, age, province);
        this.address = address;
    }

    public List<String> getAddress() {
        return address;
    }

    public void setAddress(List<String> address) {
        this.address = address;
    }

}

【JSON————->簡單JavaBean】

/** 
 * 將json格式封裝的簡單實體型別資料轉換成簡單型別的javabean（只包含簡單的資料型別）
 */  
private Object JSONtoSimpleBean() {  
    String jsonStr = "{\"age\":23,\"id\":123,\"name\":\"tt_2009\"," +  
            "\"province\":\"上海\",\"sex\":\"男\"}";  
    JSONObject jsonBean = JSONObject.fromObject(jsonStr);  
    return JSONObject.toBean(jsonBean, SimpleUser.class);  
}

【JSON—————->複雜JavaBean】

/** 
 * 將json格式封裝的複雜實體資料轉換成複雜型別的javabean（物件中包含其它複雜物件，如收貨地址用List儲存）
 */  
private static Object JSON2ComplexBean() {  
    String jsonStr = "{\"address\":[\"北京\",\"上海\",\"廣州\"]," +  
            "\"age\":23,\"id\":123,\"name\":\"tt_2009\",\"province\":\"上海\",\"sex\":\"男\"}";  
    JSONObject jsonBean = JSONObject.fromObject(jsonStr);  
    return JSONObject.toBean(jsonBean, ComplexUser.class);
解決問題：JSONObject.fromObject()方法沒有，原因沒有匯入相關的包首先給大家說一下使用json前的準備工作，需要準備下面的六個jar包：
commons-lang-1.0.4.jar 
commons-collections-2.1.jar 
commons-beanutils-1.8.0.jar 
json-lib-2.4.jar 
ezmorph-1.0.6.jar 
commons-logging-1.1.jar
需要說明幾點：
（1）json-lib最新版本可以從這個地方下載：http://sourceforge.net/projects/json-lib/files/json-lib/
（2）ezmorph是一個簡單的java類庫，用於將一種bean轉換成另外一種bean。其動態bean的實現依賴於commons-beanutils包。ezmorph可以在這個地方下載原始碼：http://sourceforge.net/projects/ezmorph/files/ezmorph/
（3）commons-beanutils是操作Java Bean的類庫，依賴於commons-collections。
（4）commons-collections類庫是各種集合類和集合工具類的封裝。三：使用Jackson框架，輕鬆轉換JSON物件（）需要匯入依賴庫的架包：jackson-all-1.7.6.jar，如果你需要轉換xml，那麼還需要stax2-api.jar1）ObjectMapper類是Jackson庫的主要類。它提供一些功能將轉換成Java物件匹配JSON結構，反之亦然。http://www.yiibai.com/jackson/jackson_objectmapper.html
2）JsonNode類是Jackson庫的一個類，該類可以很容易的操作Json格式的資料，如①獲取某個簡單json串中某個key的值②獲取某個層層巢狀的json串中某個key的值
3）SimpleModule，在自定義序列化時，才用得到。http://jackyrong.iteye.com/blog/2005323
一：後臺Java物件轉換為JSON：
1、 JavaBean(Entity/Model)轉換成JSON（writeValue()方法）
/**
 * <b>function:</b>將java物件轉換成json字串
 */
@Test
public void writeEntityJSON() {
    
    try {
        System.out.println("jsonGenerator");
        //writeObject可以轉換java物件，eg:JavaBean/Map/List/Array等
        jsonGenerator.writeObject(bean);    
        System.out.println();
        
        System.out.println("ObjectMapper");
        //writeValue具有和writeObject相同的功能
        objectMapper.writeValue(System.out, bean);
    } catch (IOException e) {
        e.printStackTrace();
    }
}



執行後結果如下：


jsonGenerator
{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}
ObjectMapper
{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}



上面分別利用JsonGenerator的writeObject方法和ObjectMapper的writeValue方法完成對Java物件的轉換，二者傳遞的引數及構造的方式不同；JsonGenerator的建立依賴於ObjectMapper物件。也就是說如果你要使用JsonGenerator來轉換JSON，那麼你必須建立一個ObjectMapper。但是你用ObjectMapper來轉換JSON，則不需要JSONGenerator。

objectMapper的writeValue方法可以將一個Java物件轉換成JSON。這個方法的引數一，需要提供一個輸出流，轉換後可以通過這個流來輸出轉換後的內容。或是提供一個File，將轉換後的內容寫入到File中。當然，這個引數也可以接收一個JSONGenerator，然後通過JSONGenerator來輸出轉換後的資訊。第二個引數是將要被轉換的Java物件。如果用三個引數的方法，那麼是一個Config。這個config可以提供一些轉換時的規則，過指定的Java物件的某些屬性進行過濾或轉換等。

2、 將Map集合轉換成Json字串（使用ajax請求時後臺常把拼接好的map格式的資料轉換成Json格式以流的形式返回）


/**
 * <b>function:</b>將map轉換成json字串
 */
@Test
public void writeMapJSON() {
    try {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("name", bean.getName());
        map.put("account", bean);
        bean = new AccountBean();
        bean.setAddress("china-Beijin");
        bean.setEmail("hoojo@qq.com");
        map.put("account2", bean);
        
        System.out.println("jsonGenerator");
        jsonGenerator.writeObject(map);
        System.out.println("");
        
        System.out.println("objectMapper");
        objectMapper.writeValue(System.out, map);
    } catch (IOException e) {
        e.printStackTrace();
    }
}



轉換後結果如下：


jsonGenerator
{"account2":{"address":"china-Beijin","name":null,"id":0,"birthday":null,"email":"hoojo@qq.com"},"name":"hoojo",
"account":{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}}
objectMapper
{"account2":{"address":"china-Beijin","name":null,"id":0,"birthday":null,"email":"hoojo@qq.com"},"name":"hoojo",
"account":{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"}}



3、 將List集合轉換成json


/**
 * <b>function:</b>將list集合轉換成json字串
 */
@Test
public void writeListJSON() {
    try {
        List<AccountBean> list = new ArrayList<AccountBean>();
        list.add(bean);
        
        bean = new AccountBean();
        bean.setId(2);
        bean.setAddress("address2");
        bean.setEmail("email2");
        bean.setName("haha2");
        list.add(bean);
        
        System.out.println("jsonGenerator");
        //list轉換成JSON字串
        jsonGenerator.writeObject(list);
        System.out.println();
        System.out.println("ObjectMapper");
        //用objectMapper直接返回list轉換成的JSON字串
        System.out.println("1###" + objectMapper.writeValueAsString(list));
        System.out.print("2###");
        //objectMapper list轉換成JSON字串
        objectMapper.writeValue(System.out, list);
    } catch (IOException e) {
        e.printStackTrace();
    }
}



結果如下：


jsonGenerator
[{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"},
{"address":"address2","name":"haha2","id":2,"birthday":null,"email":"email2"}]
ObjectMapper
1###[{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"},
{"address":"address2","name":"haha2","id":2,"birthday":null,"email":"email2"}]
2###[{"address":"china-Guangzhou","name":"hoojo","id":1,"birthday":null,"email":"hoojo_@126.com"},
{"address":"address2","name":"haha2","id":2,"birthday":null,"email":"email2"}]



外面就是多了個[]中括號；同樣Array也可以轉換，轉換的JSON和上面的結果是一樣的，這裡就不再轉換了。~.~

4、下面來看看jackson提供的一些型別，用這些型別完成json轉換；如果你使用這些型別轉換JSON的話，那麼你即使沒有JavaBean(Entity)也可以完成複雜的Java型別的JSON轉換。下面用到這些型別構建一個複雜的Java物件，並完成JSON轉換。


@Test
public void writeOthersJSON() {
    try {
        String[] arr = { "a", "b", "c" };
        System.out.println("jsonGenerator");
        String str = "hello world jackson!";
        //byte
        jsonGenerator.writeBinary(str.getBytes());
        //boolean
        jsonGenerator.writeBoolean(true);
        //null
        jsonGenerator.writeNull();
        //float
        jsonGenerator.writeNumber(2.2f);
        //char
        jsonGenerator.writeRaw("c");
        //String
        jsonGenerator.writeRaw(str, 5, 10);
        //String
        jsonGenerator.writeRawValue(str, 5, 5);
        //String
        jsonGenerator.writeString(str);
        jsonGenerator.writeTree(JsonNodeFactory.instance.POJONode(str));
        System.out.println();
        
        //Object
        jsonGenerator.writeStartObject();//{
        jsonGenerator.writeObjectFieldStart("user");//user:{
        jsonGenerator.writeStringField("name", "jackson");//name:jackson
        jsonGenerator.writeBooleanField("sex", true);//sex:true
        jsonGenerator.writeNumberField("age", 22);//age:22
        jsonGenerator.writeEndObject();//}
        
        jsonGenerator.writeArrayFieldStart("infos");//infos:[
        jsonGenerator.writeNumber(22);//22
        jsonGenerator.writeString("this is array");//this is array
        jsonGenerator.writeEndArray();//]
        
        jsonGenerator.writeEndObject();//}
        
        
        AccountBean bean = new AccountBean();
        bean.setAddress("address");
        bean.setEmail("email");
        bean.setId(1);
        bean.setName("haha");
        //complex Object
        jsonGenerator.writeStartObject();//{
        jsonGenerator.writeObjectField("user", bean);//user:{bean}
        jsonGenerator.writeObjectField("infos", arr);//infos:[array]
        jsonGenerator.writeEndObject();//}
        
    } catch (Exception e) {
        e.printStackTrace();
    }
}



執行後，結果如下：


jsonGenerator
"aGVsbG8gd29ybGQgamFja3NvbiE=" true null 2.2c world jac  worl "hello world jackson!" "hello world jackson!"
 {"user":{"name":"jackson","sex":true,"age":22},"infos":[22,"this is array"]} 
{"user":{"address":"address","name":"haha","id":1,"birthday":null,"email":"email"},"infos":["a","b","c"]}



怎麼樣？構造的json字串和輸出的結果是一致的吧。關鍵看懂用JSONGenerator提供的方法，完成一個Object的構建。

二：JSON轉換為Java物件



1、 將json字串轉換成JavaBean物件


@Test
public void readJson2Entity() {
    String json = "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}";
    try {
        AccountBean acc = objectMapper.readValue(json, AccountBean.class);
        System.out.println(acc.getName());
        System.out.println(acc);
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}



很簡單，用到了ObjectMapper這個物件的readValue這個方法，這個方法需要提供2個引數。第一個引數就是解析的JSON字串，第二個引數是即將這個JSON解析成什麼Java物件，即Java物件的型別。當然，還有其他相同簽名方法，有興趣可以一一嘗試使用方法，當然使用的方法和當前使用的方法大同小異。執行後，結果如下：


haha
haha#1#address#null#email



2、 將json字串轉換成List<Map>集合


/**
 * <b>function:</b>json字串轉換成list<map>
 */
@Test
public void readJson2List() {
    String json = "[{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"+
                "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}]";
    try {
        List<LinkedHashMap<String, Object>> list = objectMapper.readValue(json, List.class);
        System.out.println(list.size());
        for (int i = 0; i < list.size(); i++) {
            Map<String, Object> map = list.get(i);
            Set<String> set = map.keySet();
            for (Iterator<String> it = set.iterator();it.hasNext();) {
                String key = it.next();
                System.out.println(key + ":" + map.get(key));
            }
        }
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}



嘗試過將上面的JSON轉換成List，然後List中存放AccountBean，但結果失敗了。但是支援Map集合。因為你轉成List.class，但是不知道List存放何種型別。只好默然Map型別。因為所有的物件都可以轉換成Map結合，執行後結果如下：


2
address:address2
name:haha2
id:2
email:email2
address:address
name:haha
id:1
email:email



3、 Json字串轉換成Array陣列，由於上面的泛型轉換不能識別到集合中的物件型別。所有這裡用物件陣列，可以解決這個問題。只不過它不再是集合，而是一個陣列。當然這個不重要，你可以用Arrays.asList將其轉換成List即可。


/**
 * <b>function:</b>json字串轉換成Array
 * @author hoojo
 * @createDate 2010-11-23 下午06:14:01
 */
@Test
public void readJson2Array() {
    String json = "[{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"+
            "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}]";
    try {
        AccountBean[] arr = objectMapper.readValue(json, AccountBean[].class);
        System.out.println(arr.length);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}



執行後的結果：


2
haha2#2#address2#null#email2
haha#1#address#null#email



4、 Json字串轉換成Map集合


/**
 * <b>function:</b>json字串轉換Map集合
 * @author hoojo
 * @createDate Nov 27, 2010 3:00:06 PM
 */
@Test
public void readJson2Map() {
    String json = "{\"success\":true,\"A\":{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"+
                "\"B\":{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}}";
    try {
        Map<String, Map<String, Object>> maps = objectMapper.readValue(json, Map.class);
        System.out.println(maps.size());
        Set<String> key = maps.keySet();
        Iterator<String> iter = key.iterator();
        while (iter.hasNext()) {
            String field = iter.next();
            System.out.println(field + ":" + maps.get(field));
        }
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}



執行後結果如下：


3
success:true
A:{address=address2, name=haha2, id=2, email=email2}
B:{address=address, name=haha, id=1, email=email}

三：Jackson對XML的支援：
Jackson也可以完成java物件到xml的轉換，轉換後的結果要比json-lib更直觀，不過它依賴於stax2-api.jar這個jar包。
/**
 * <b>function:</b>java物件轉換成xml文件
 * 需要額外的jar包 stax2-api.jar
 * @author hoojo
 * @createDate 2010-11-23 下午06:11:21
 */
@Test
public void writeObject2Xml() {
    //stax2-api-3.0.2.jar
    System.out.println("XmlMapper");
    XmlMapper xml = new XmlMapper();
    
    try {
        //javaBean轉換成xml
        //xml.writeValue(System.out, bean);
        StringWriter sw = new StringWriter();
        xml.writeValue(sw, bean);
        System.out.println(sw.toString());
        //List轉換成xml
        List<AccountBean> list = new ArrayList<AccountBean>();
        list.add(bean);
        list.add(bean);
        System.out.println(xml.writeValueAsString(list));
        
        //Map轉換xml文件
        Map<String, AccountBean> map = new HashMap<String, AccountBean>();
        map.put("A", bean);
        map.put("B", bean);
        System.out.println(xml.writeValueAsString(map));
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
執行上面的方法，結果如下：
XmlMapper
<unknown><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></unknown>
<unknown><unknown><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></unknown>
<email><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></email></unknown>
<unknown><A><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></A>
<B><address>china-Guangzhou</address><name>hoojo</name><id>1</id><birthday/><email>hoojo_@126.com</email></B></unknown>
看結果，根節點都是unknown 這個問題還沒有解決，由於根節點沒有轉換出來，所有導致解析xml到Java物件，也無法完成。

Java與Json資料格式轉換
2014-08-21
JavaJSON
Map 轉json資料，json資料轉換為Map
2016-06-17
JSON
把JSON資料格式轉換為Python的類物件
2019-06-04
JSONPython物件
將任意格式轉換為JSON資料格式的工具類
2012-07-06
JSON
將json資料轉換為Python字典將json資料轉換為Python字典
2023-11-07
JSONPython
Go語言轉換JSON資料
2014-08-26
GoJSON
VC常用資料型別使用轉換詳解 (轉)
2008-03-27
資料型別
ADO資料與XML資料間的轉換的類(ASP實現) (轉)
2007-11-05
XML
C#資料型別及其轉換詳解
2020-07-10
C#資料型別
VC常用資料型別使用轉換詳解
2005-09-13
資料型別
淘寶資料：2010年度淘寶各品類銷售資料及成交銷量前10品牌
2011-01-29
Gson轉換 — json資料轉換為Object實體公共方法
2017-05-23
JSONObject
【Java】基本資料、包裝類間轉換與處理
2019-08-11
Java
[Java] 基本資料、包裝類間轉換與處理
2019-08-11
Java
JavaScript和json對資料格式的轉換
2017-12-26
JavaScriptJSON
詳解MAC硬碟中各個資料夾
2012-09-26
Mac硬碟
用兩種方法把JSON資料格式轉換為Python的類物件
2020-03-17
JSONPython物件
探索多種資料格式：JSON、YAML、XML、CSV等資料格式詳解與比較
2024-03-28
JSONYAMLXML
程佩君:VC常用資料型別使用轉換詳解 (轉)
2007-12-07
資料型別
為啥我的字典資料轉換不成 json？
2020-08-28
JSON
javascript資料型別隱式和顯式轉換詳解
2017-03-31
JavaScript資料型別
C#中JSON轉換類
2018-09-07
C#JSON
轉型大資料及操作流程
2018-05-13
大資料
Python JSON 使用指南：解析和轉換資料
2023-11-01
PythonJSON
資料匯入與預處理實驗二---json格式檔案轉換
2020-09-26
JSON
JSON編碼格式提交表單資料詳解
2014-12-02
JSON
JavaScript 資料型別轉換詳細解釋已經parseInt等
2020-11-09
JavaScript資料型別
資料庫檢視詳解 (轉)
2010-09-06
資料庫
Java 第9 章：資料表與簡單Java類對映轉換
2020-12-01
Java
SQL SERVER 與ACCESS、EXCEL的資料轉換 (轉)
2007-08-15
SQLServerExcel
Antd：Tree樹形控制元件資料解析（JSON轉換）
2019-02-20
控制元件JSON
$.parseJSON()方法將json資料轉換為物件直接量
2017-03-30
JSON物件
將Json資料轉換為ADO.NET DataSet物件
2015-02-02
JSON物件
fastJson在java後臺轉換json格式資料探究
2015-11-02
ASTJSONJava
Django資料庫類庫MySQLdb使用詳解
2018-03-27
Django資料庫MySql
機器學習-- 資料轉換
2018-11-17
機器學習
Sqoop解決關係型資料庫與HDFS之間進行資料轉換
2016-05-05
OOP資料庫
python 與 Mysql 資料型別轉換
2020-05-11
PythonMySQL 資料型別

JSON資料及與其他各類資料轉換詳解

相關文章