fastjson json字串和JavaBean、List、Map及複雜集合型別的相互轉換。

阿新 • • 發佈：2019-01-13

本文主要示例兩部分內容：

JavaBean、List、Map、複雜集合轉換成 json字串；
json字串轉換成 JavaBean、List、Map、複雜集合；

定義POJO：

public class A {

    private String usename;
    private String password;

    public A() {
    }

    public A(String usename, String password) {
        this.usename = usename;
        this.password = password;
    }

    public 
 String getUsename() {
        return usename;
    }

    public void setUsename(String usename) {
        this.usename = usename;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

開始轉換測試：

public static void main(String[] args) {

        //javaBean 轉 json字串
        A a1 = new A("wei.hu", "123456");

        String a1Json = JSON.toJSONString(a1);
        System.out.println(a1Json);



        //List<JavaBean> 轉 json字串
        A a2 = new A("mengna.shi", "123456");
        A a3 = new 
 A("ming.li", "567890");

        List<A> aList = Lists.newArrayList(a1, a2, a3);
        String aListJson = JSON.toJSONString(aList);
        System.out.println(aListJson);

        //List<String> 轉 json字串
        List<String> stringList = Lists.newArrayList("wei.hu", "mengna.shi", "fastJson");

        String stringListJson = JSON.toJSONString(stringList);
        System.out.println(stringListJson);

        //List<Integer> 轉 json字串
        List<Integer> integerList = Lists.newArrayList(10, 9, 8, 7);

        String integerListJson = JSON.toJSONString(integerList);
        System.out.println(integerListJson);



        //Map<String, A> 轉 json字串
        Map<String, A> aMap = Maps.newHashMap();
        aMap.put("a1", a1);
        aMap.put("a2", a2);
        aMap.put("a3", a3);

        String aMapJson = JSON.toJSONString(aMap);
        System.out.println(aMapJson);

        //Map<String, String> 轉 json字串
        Map<String, String> stringMap = Maps.newHashMap();
        stringMap.put("name", "wei.hu");
        stringMap.put("gender", "man");
        stringMap.put("age", "18");

        String stringMapJson = JSON.toJSONString(stringMap);
        System.out.println(stringMapJson);

        //Map<String, Integer> 轉 json字串
        Map<String, Integer> integerMap = Maps.newHashMap();
        integerMap.put("int1",18);
        integerMap.put("int2", 19);
        integerMap.put("int3", 20);

        String integerMapJson = JSON.toJSONString(integerMap);
        System.out.println(integerMapJson);

        //Map<String, Object> 轉 json字串
        Map<String, Object> objectMap = Maps.newHashMap();
        objectMap.put("name", "wei.hu");
        objectMap.put("gender", "man");
        objectMap.put("age", 18);

        String objectMapJson = JSON.toJSONString(objectMap);
        System.out.println(objectMapJson);



        //List<Map<String,Object>> 轉 json字串
        Map<String, A> aMap1 = Maps.newHashMap();
        aMap1.put("a1", a1);
        aMap1.put("a2", a2);

        List<Map<String, A>> aList1 = Lists.newArrayList();
        aList1.add(aMap);
        aList1.add(aMap1);

        String complexJson1 = JSON.toJSONString(aList1);
        System.out.println(complexJson1);

        //Map<String, List<JavaBean>> 轉 json字串
        List<A> aList2 = Lists.newArrayList(a1, a2);
        List<A> aList3 = Lists.newArrayList(a2, a3);

        Map<String, List<A>> listMap = Maps.newHashMap();
        listMap.put("key1", aList2);
        listMap.put("key2", aList3);

        String complexJson2 = JSON.toJSONString(listMap);
        System.out.println(complexJson2);



        //json字串 轉 javaBean
        String jsonString1 = "{\"password\":\"123456\",\"usename\":\"wei.hu\"}";

        A aa1 = JSON.parseObject(jsonString1, A.class);
        System.out.println(aa1.getUsename() + " / " + aa1.getPassword());


        //json字串 轉 List<JavaBean>
        String jsonString2 = "[{\"password\":\"123456\",\"usename\":\"wei.hu\"},{\"password\":\"123456\",\"usename\":\"mengna.shi\"},{\"password\":\"567890\",\"usename\":\"ming.li\"}]";

        List<A> aList4 = JSON.parseArray(jsonString2, A.class);
        System.out.println(aList4.size());


        //json字串 轉 List<String>
        String jsonString3 = "[\"wei.hu\",\"mengna.shi\",\"fastJson\"]";

        List<String> stringList1 = JSON.parseArray(jsonString3, String.class);
        System.out.println(stringList1.size());


        //json字串 轉 List<Integer>
        String jsonString4 = "[10,9,8,7]";

        List<Integer> integerList1 = JSON.parseArray(jsonString4, Integer.class);
        System.out.println(integerList1.size());


        //json字串轉 Map<String, Object>
        String jsonString5 = "{\"a1\":{\"password\":\"123456\",\"usename\":\"wei.hu\"},\"a2\":{\"password\":\"123456\",\"usename\":\"mengna.shi\"},\"a3\":{\"password\":\"567890\",\"usename\":\"ming.li\"}}";

        Map<String, Object> stringObjectMap = JSON.parseObject(jsonString5, Map.class);
        System.out.println(stringObjectMap.size());



        //json字串 轉 List<Map<String, A>>
        String jsonString6 = "[{\"a1\":{\"password\":\"123456\",\"usename\":\"wei.hu\"},\"a2\":{\"password\":\"123456\",\"usename\":\"mengna.shi\"},\"a3\":{\"password\":\"567890\",\"usename\":\"ming.li\"}},{\"a1\":{\"$ref\":\"$[0].a1\"},\"a2\":{\"$ref\":\"$[0].a2\"}}]";

        List<Map<String, A>> mapList = JSON.parseObject(jsonString6, new TypeReference<List<Map<String, A>>>(){});
        System.out.println("mapList.size():" + mapList.size());

        //json字串 轉 Map<String, List<A>>
        String jsonString7 = "{\"key1\":[{\"password\":\"123456\",\"usename\":\"wei.hu\"},{\"password\":\"123456\",\"usename\":\"mengna.shi\"}],\"key2\":[{\"$ref\":\"$.key1[1]\"},{\"password\":\"567890\",\"usename\":\"ming.li\"}]}";

        Map<String, List<A>> listMap1 = JSON.parseObject(jsonString7, new TypeReference<Map<String, List<A>>>() {});
        System.out.println("listMap1.size():" + listMap1.size());


        //json字串 轉 List<Map<String, List<A>>>
        A aaa1 = new A("wei.hu", "123456");
        A aaa2 = new A("mengna.shi", "abcdef");
        A aaa3 = new A("admin", "098765");
        List<A> myAList1 = Lists.newArrayList(aaa1, aaa2, aaa3);

        A aaa4 = new A("song.xu", "28");
        A aaa5 = new A("jielun.zhou", "36");
        List<A> myAList2 = Lists.newArrayList(aaa4, aaa5);

        Map<String, List<A>> myMap1 = Maps.newHashMap();
        myMap1.put("myAList1", myAList1);
        myMap1.put("myAList2", myAList2);


        A aaa6 = new A("junjie.lin", "61");
        A aaa7 = new A("jian.xiao", "31");
        A aaa8 = new A("xi.ben", "32");
        List<A> myAList3 = Lists.newArrayList(aaa6, aaa7, aaa8);

        Map<String, List<A>> myMap2 = Maps.newHashMap();
        myMap2.put("myAList3", myAList3);


        A aaa9 = new A("xing.qun", "33");
        A aaa10 = new A("datong.fang", "34");
        A aaa11 = new A("dun.tong", "35");
        List<A> myAList4 = Lists.newArrayList(aaa9, aaa10, aaa11);

        Map<String, List<A>> myMap3 = Maps.newHashMap();
        myMap3.put("myAList4", myAList4);

        List<Map<String, List<A>>> list = Lists.newArrayList(myMap1, myMap2, myMap3);

        System.out.println(JSON.toJSONString(list));

        List<Map<String, List<A>>> newList = JSON.parseObject(JSON.toJSONString(list), new TypeReference<List<Map<String, List<A>>>>() {});
        System.out.println("newList.size():" + newList.size());


        //josn字串 轉 Map<String, List<Map<String, A>>>
        A objectA1 = new A("1", "1");
        A objectA2 = new A("2", "2");
        A objectA3 = new A("3", "3");

        Map<String, A> newMap1 = Maps.newHashMap();
        newMap1.put("objectA1", objectA1);
        newMap1.put("objectA2", objectA2);
        newMap1.put("objectA3", objectA3);


        A objectA4 = new A("4", "4");
        A objectA5 = new A("5", "5");
        A objectA6 = new A("6", "6");

        Map<String, A> newMap2 = Maps.newHashMap();
        newMap2.put("objectA4", objectA4);
        newMap2.put("objectA5", objectA5);
        newMap2.put("objectA6", objectA6);

        List<Map<String, A>> newList1 = Lists.newArrayList(newMap1, newMap2);


        A objectA7 = new A("7", "7");
        A objectA8 = new A("8", "8");

        Map<String, A> newMap3 = Maps.newHashMap();
        newMap3.put("objectA7", objectA7);
        newMap3.put("objectA8", objectA8);

        List<Map<String, A>> newList2 = Lists.newArrayList(newMap3);


        A objectA9 = new A("9", "9");
        A objectA0 = new A("0", "0");

        Map<String, A> newMap4 = Maps.newHashMap();
        newMap4.put("objectA9", objectA9);
        newMap4.put("objectA0", objectA0);

        List<Map<String, A>> newList3 = Lists.newArrayList(newMap4);

        Map<String, List<Map<String, A>>> map = Maps.newHashMap();
        map.put("newList1", newList1);
        map.put("newList2", newList2);
        map.put("newList3", newList3);

        System.out.println(JSON.toJSONString(map));


        Map<String, List<Map<String, A>>> newMap = JSON.parseObject(JSON.toJSONString(map), new TypeReference<Map<String, List<Map<String, A>>>>() {});
        System.out.println("newMap.size()" + newMap.size());
    }

輸出：

{"password":"123456","usename":"wei.hu"}
[{"password":"123456","usename":"wei.hu"},{"password":"123456","usename":"mengna.shi"},{"password":"567890","usename":"ming.li"}]
["wei.hu","mengna.shi","fastJson"]
[10,9,8,7]
{"a1":{"password":"123456","usename":"wei.hu"},"a2":{"password":"123456","usename":"mengna.shi"},"a3":{"password":"567890","usename":"ming.li"}}
{"gender":"man","name":"wei.hu","age":"18"}
{"int2":19,"int1":18,"int3":20}
{"gender":"man","name":"wei.hu","age":18}
[{"a1":{"password":"123456","usename":"wei.hu"},"a2":{"password":"123456","usename":"mengna.shi"},"a3":{"password":"567890","usename":"ming.li"}},{"a1":{"$ref":"$[0].a1"},"a2":{"$ref":"$[0].a2"}}]
{"key1":[{"password":"123456","usename":"wei.hu"},{"password":"123456","usename":"mengna.shi"}],"key2":[{"$ref":"$.key1[1]"},{"password":"567890","usename":"ming.li"}]}
wei.hu / 123456
3
3
4
3
mapList.size():2
listMap1.size():2
[{"myAList2":[{"password":"28","usename":"song.xu"},{"password":"36","usename":"jielun.zhou"}],"myAList1":[{"password":"123456","usename":"wei.hu"},{"password":"abcdef","usename":"mengna.shi"},{"password":"098765","usename":"admin"}]},{"myAList3":[{"password":"61","usename":"junjie.lin"},{"password":"31","usename":"jian.xiao"},{"password":"32","usename":"xi.ben"}]},{"myAList4":[{"password":"33","usename":"xing.qun"},{"password":"34","usename":"datong.fang"},{"password":"35","usename":"dun.tong"}]}]
newList.size():3
{"newList3":[{"objectA9":{"password":"9","usename":"9"},"objectA0":{"password":"0","usename":"0"}}],"newList2":[{"objectA7":{"password":"7","usename":"7"},"objectA8":{"password":"8","usename":"8"}}],"newList1":[{"objectA2":{"password":"2","usename":"2"},"objectA3":{"password":"3","usename":"3"},"objectA1":{"password":"1","usename":"1"}},{"objectA6":{"password":"6","usename":"6"},"objectA4":{"password":"4","usename":"4"},"objectA5":{"password":"5","usename":"5"}}]}
newMap.size()3

fastjson json字串和JavaBean、List、Map及複雜集合型別的相互轉換。

本文主要示例兩部分內容： JavaBean、List、Map、複雜集合轉換成 json字串； json字串轉換成 JavaBean、List、Map、複雜集合；定義POJO： public class A { private Str

用第三方工具類，將JavaBean、List、Map<String,Object>轉成JSON文字

匯入第三方jar包：》commons-beanutils-1.7.0.jar 》commons-collections-3.1.jar 》commons-lang-2.5.jar &nb

java bean、List、陣列、map和Json的相互轉化

package com.my.json; import java.util.ArrayList; import java.util.List; import java.util.Map; import net.sf.json.JSONArray; import net.sf.json.J

json字串與Object、List、Map的互轉工具類

package com.cq2022.zago.base.util; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.Stri

java json轉map（複雜混合型別list、map和string）

其中用到了instanceof，所需的jar包看例子： package json; import java.util.List; import java.util.Map; import net

FastJson 陣列、List、Set、Map基本序列化與日期格式化

摘要： FastJson可以直接序列化陣列、List、Set、Map等，也可以直接支援日期型別資料的格式化，包括java.util.Date、java.sql.Date、java.sql.Timestamp、java.sql.Time。 FastJson不僅可以支援普通

FastJson 數組、List、Set、Map基本序列化與日期格式化

混合 sta 日期類 hang EDA time json2 fas nta 摘要： FastJson可以直接序列化數組、List、Set、Map等，也可以直接支持日期類型數據的格式化，包括java.util.Date、java.sql.Date、java.sql.Time

python知識整理--議可變物件和不可變物件以及str、list、tuple、dict、set

可變物件：變數、list 不可變物件：str、tuple、dict、set 1、變數是可變的不用多說，變數賦值一次便改變一次。 2、list 可變物件，可對list進行如下新增刪除排序等操作。 list = [2,3,5,1,2] list.append(8) list.insert(0,

JSON字串和list集合互轉

谷歌的Gson.jar： //list轉換為json Gson gson = new Gson(); List<Person&g

fastJson中常用JSON字串和Java物件互轉

1.使用fastJson，首先引入fastJson依賴  <dependency> <groupId>com.alibaba<

字串和編碼（ASCII 、Unicode、UTF-8）

計算機只能處理數字，如果要處理文字，就必須先把文字轉換為數字才能處理。最早的計算機在設計時採用8個位元（bit）作為一個位元組（byte），所以，一個位元組能表示的最大的整數就是255（二進位制11111111=十進位制255），如果要表示更大的整數，就必須用更多的位元組。

使用 fastjson 在java中進行 json字串和物件的互轉

前提：我們在這裡只使用fastjson的轉json的jar依賴包 <dependency> <groupId>com.alibaba</groupId> <ar

【java讀書筆記】——Collection集合之六大介面（Collection、Set、List、Map、Iterator和Comparable）

兩個月之前準備軟考時，簡單的從理論上總結了最常用的資料結構和演算法，比如：線性表，連結串列，圖。在進行java開發時，jdk為我們提供了一系列相應的類來實現基本的資料結構。jdk所提供的

技術筆記：字串、List、陣列、日期等常見操作方法

string類 string s="ABC科學";int i=s.IndexOf("科");//字串的搜尋。 int n=string.Compare(s1,s2);//n=0則兩個相同。n< 0

STL中vector、list、deque和map的區別

map映照容器的元素資料是一個鍵值和一個映照資料組成的，鍵值與映照資料之間具有一一映照的關係。 map映照容器的資料結構是採用紅黑樹來實現的，插入鍵值的元素不允許重複，比較函式只對元素的鍵值進行比較，元素的各項資料可通過鍵值檢索出來。使用map容器需要標頭檔案包含語句“#

fastJson json字串轉List以及Map

fastJson是阿里出品的json處理外掛，比較輕量、易用，國內很多公司都應用於生產系統中。一般的Web應用程式為了更好的使用者體驗，在頁面中使用了ajax技術，非同步載入資料，或者提

object轉json字串時NULL值欄位過濾及map、json互轉後map型別問題

HashMap<String, Fbox> map_in = new HashMap<>(); HashMap<String, Map<String, Fbox>> map_out= new HashMap<>()

Spring中使用Map、Set、List、數組、屬性集合的註入方法配置文件

查看 main list highlight 配置 spring配置 pla lec while （1）下邊的一個Java類包含了所有Map、Set、List、數組、屬性集合等這些容器，主要用於演示spring的註入配置； [java] view plain c

go語言中container容器數據結構heap、list、ring

func 都是 slice 比較 next println div less 插入元素 heap堆的使用： package main import ( "container/heap" "fmt" ) type IntHeap []int

java並發容器(Map、List、BlockingQueue)具體解釋

current 兩種避免由於新的 rom 就會 family err Java庫本身就有多種線程安全的容器和同步工具，當中同步容器包含兩部分：一個是Vector和Hashtable。另外還有JDK1.2中增加的同步包裝類。這些類都是由Collections.s

fastjson json字串和JavaBean、List、Map及複雜集合型別的相互轉換。

相關推薦