// 被解析的是参数json，json 是一个json字符串，包含了一个数组，形如[ { ....  },{.....},{.....} ]，本函数将json 数组解析到 list<string>,list中每个元素为 {....}



    public  List<string> getArrayFromJson(string json )

    {


        List<string> lst = new System.Collections.Generic.List<string>();



         string pat=@( \[ ).*( \] )";  //【注意，这里的正则表达式无法正常显示，看下面的图】定义正则表达式，解析得到  [ 与 ] 之间的内容，内容包括 [ 和 ]

      

       Match matched = Regex.Match(json.Replace("'", ""), pat, RegexOptions.IgnoreCase); //去掉json中单引号，然后解析得到 [ 与 ] 之间内容，保存在matched中



        pat = @"(\{).*?(\})"; //解析得到  { 与 } 之间的内容，内容包括 { 和 }；要注意这个 .*? 的写法， 附加的问号是表示尽可能短匹配，这很重要，否则返回最长匹配



         // 将 matched  中的内容，利用正则表达式 解析出来，结果就是 每个{ 与 } 之间的内容【表示一个数组】。每个被解析出来的数组都保存在 matches 中

        

        MatchCollection matches = Regex.Matches( matched.Value.Replace("[","").Replace("]",""), pat, RegexOptions.IgnoreCase);



     // 得到每个matches 中的字符串

        foreach (Match m in matches)

        {

            lst.Add(m.Value);

        }


        return lst;


    }





  

假如json字符串长这样：
"data": [
            {
                "businessno": "80028654975927596765872299",
                "comcode": "3102445673",
                "RiskCode": "7545",
                "ChannelType": "03",
                "UnderWriteEndDate": "2020-07-22 00:00:00",
                "StartDate": "2020-07-22 00:00:00",
                "EndDate": "2021-07-21 00:00:00",
                "ExchangeRate": "1",
                "CoinsRate": "1",
                "SumAmount": "500000",
                "SumPremium": "47.17",
                "shareAgentFee": "0",
                "handlercode": "34965826093411546",
                "handlername": "如花"
            }
        ]

如果要获取businessno的值，可以这样
String bussno = (String) JSONObject.parseArray(dataStr).getJSONObject(0).get("businessno");

0是第一个json串的意思
要先导入依赖
<dependency>
2            <groupId>com.alibaba</groupId>
3             <artifactId>fastjson</artifactId>
4             <version>1.2.7</version>
5         </dependency>	  

通过http://blog.csdn.net/vincent_czz/article/details/7333977，找到了自己所需要的，--->写的更全面，  我写的是自己需要的部分             -----android菜鸟


json 语句：{

    "state": "OK",

    "type": [

        {

            "add_time": "2015-10-14",

            "attr_id": "86",

            "attr_name": "五金工具",

            "image": "http://www.layib.com/data/files/marchine_type/9155151.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "87",

            "attr_name": "市政园林",

            "image": "http://www.layib.com/data/files/marchine_type/7042480.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "88",

            "attr_name": "起重机械",

            "image": "http://www.layib.com/data/files/marchine_type/7828002.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "89",

            "attr_name": "工业车辆",

            "image": "http://www.layib.com/data/files/marchine_type/5010833.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "90",

            "attr_name": "路面设备",

            "image": "http://www.layib.com/data/files/marchine_type/7391571.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "91",

            "attr_name": "能源设备",

            "image": "http://www.layib.com/data/files/marchine_type/8926086.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "92",

            "attr_name": "路面设备",

            "image": "http://www.layib.com/",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "93",

            "attr_name": "物料运输",

            "image": "http://www.layib.com/data/files/marchine_type/2378234.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "94",

            "attr_name": "高空作业",

            "image": "http://www.layib.com/data/files/marchine_type/7522308.jpg",

            "parent_id": "79",

            "sort_order": "255"

        },

        {

            "add_time": "2015-10-26",

            "attr_id": "95",

            "attr_name": "建筑建材",

            "image": "http://www.layib.com/data/files/marchine_type/1149139.jpg",

            "parent_id": "79",

            "sort_order": "255"

        }

    ]

}


、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
使用的xutils获取的json语句



private List<String> getWuZiShaiXuanData(){
    List<String> wuziShaiXuanData = new ArrayList<>();

    HttpUtils httpUtils = new HttpUtils();

    httpUtils.send(HttpRequest.HttpMethod.GET, Utils.WUZI_ZULIN, new RequestCallBack<String>() {
        @Override
        public void onSuccess(ResponseInfo<String> responseInfo) {
            String result = responseInfo.result;

            try {
                JSONObject jsonObject = new JSONObject(result);

                JSONArray typeList = jsonObject.getJSONArray("type");

                int length = typeList.length();

                for (int i = 0;i<length;i++){
                    JSONObject oj = typeList.getJSONObject(i);
                    String name = (String) oj.get("attr_name");	

                    wuziShaiXuanData.add(name);
                }

                Toast.makeText(BaseActivity.this,wuziShaiXuanData.toString(),Toast.LENGTH_SHORT).show();

            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onFailure(HttpException e, String s) {

        }
    });

    return wuziShaiXuanData;
}



二.碰到的另一种json语句


{
    "state": "OK",
        "type": {
    "100": "xx组",
            "101": "xx组",
            "102": "xx组",
            "103": "xx组",
            "104": "xx组",
            "105": "xx组",
            "65": "xx组",
            "66": "xx组",
            "97": "xx组",
            "98": "xx组",
            "99": "xx组"
	}
}






我自己的解析方式：

httpUtils.send(HttpRequest.HttpMethod.GET, Utils.BANZU_TYPE, new RequestCallBack<String>() {
    @Override
    public void onSuccess(ResponseInfo<String> responseInfo) {

        String result = responseInfo.result;

        try {
            JSONObject jsonObject = new JSONObject(result);

            String result_type = jsonObject.getString("type");

            jsonObject = new JSONObject(result_type);

            Iterator<String> iterator = jsonObject.keys();

            while (iterator.hasNext()) {

                String key = iterator.next();

                String value = jsonObject.getString(key);

                banzuData.add(value);      // List<String> banzuData


                banzuDataTypeHashMap.put(value,key);

            }

        } catch (JSONException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void onFailure(HttpException e, String s) {

    }
});

转载：https://yq.aliyun.com/articles/60730

如何从PostgreSQL json中提取数组 

作者 

digoal

日期 

2016-09-10

标签 

PostgreSQL , json , 数组 , jsonb

背景 

在PostgreSQL中使用JSON类型时，除了能存，大家更关心的是JSON中的数据的使用，例如 

1. VALUE支持哪些类型，

通过以下方法可以提取JSON最外层的VALUE的数据类型

json_typeof(json) 

jsonb_typeof(jsonb) 

目前支持的类型如下 

object, array, string, number, boolean, and null


包含哪些KEY或VALUE，通过路径提取KEY或VALUE等。
通过制定KEY提取VALUE， 

通常通过KEY提取的VALUE还是JSON或JSONB类型，因为JSON本身就是嵌套的，但是可以通过json typeof得知它的类型。


json_typeof(json) 

jsonb_typeof(jsonb) 

但是SQL还是认为他是个JSON，要么就是转换为TEXT。

postgres=# create table t3(c1 jsonb); 

CREATE TABLE 

postgres=# insert into t3 values (‘{“a”:”v”,”b”:12,”c”:{“ab”:”hello”},”d”:12.3,”e”:true,”f”:[1,2,3,4],”g”:[“a”,”b”]}’); 

INSERT 0 1  

postgres=# select pg_typeof(col), jsonb_typeof(col),col from (select c1->’a’ col from t3) t; 

 pg_typeof | jsonb_typeof | col 

———–+————–+—– 

 jsonb     | string       | “v” 

(1 row)  

postgres=# select pg_typeof(col), jsonb_typeof(col),col from (select c1->’b’ col from t3) t; 

 pg_typeof | jsonb_typeof | col 

———–+————–+—– 

 jsonb     | number       | 12 

(1 row)  

postgres=# select pg_typeof(col), jsonb_typeof(col),col from (select c1->’c’ col from t3) t; 

 pg_typeof | jsonb_typeof |       col 

———–+————–+—————– 

 jsonb     | object       | {“ab”: “hello”} 

(1 row)  

postgres=# select pg_typeof(col), jsonb_typeof(col),col from (select c1->’d’ col from t3) t; 

 pg_typeof | jsonb_typeof | col 

———–+————–+—— 

 jsonb     | number       | 12.3 

(1 row)  

postgres=# select pg_typeof(col), jsonb_typeof(col),col from (select c1->’e’ col from t3) t; 

 pg_typeof | jsonb_typeof | col 

———–+————–+—— 

 jsonb     | boolean      | true 

(1 row)  

postgres=# select pg_typeof(col), jsonb_typeof(col),col from (select c1->’f’ col from t3) t; 

 pg_typeof | jsonb_typeof |     col 

———–+————–+————– 

 jsonb     | array        | [1, 2, 3, 4] 

(1 row)  

postgres=# select pg_typeof(col), jsonb_typeof(col),col from (select c1->’g’ col from t3) t; 

 pg_typeof | jsonb_typeof |    col 

———–+————–+———— 

 jsonb     | array        | [“a”, “b”] 

(1 row) 

4. 特定VALUE类型的处理，例如数组。

当VALUE是ARRAY时，如果需要返回ARRAY给SQL层，暂时还没有内置这样的操作符，需要自定义，本文将介绍。

如何返回JSON中存储的数组 

大多数JSON操作符，返回的要么是TEXT要么是JSON.

例如以下查询 

操作符->返回数组

postgres=# select pg_typeof(‘{“a”:[1,2,3],”b”:[4,5,6]}’::json->’a’), ‘{“a”:[1,2,3],”b”:[4,5,6]}’::json->’a’; 

 pg_typeof | ?column? 

———–+———- 

 json      | [1,2,3] 

(1 row) 

操作符->>返回text

postgres=# select pg_typeof(‘{“a”:[1,2,3],”b”:[4,5,6]}’::json->>’a’), ‘{“a”:[1,2,3],”b”:[4,5,6]}’::json->>’a’; 

 pg_typeof | ?column? 

———–+———- 

 text      | [1,2,3] 

(1 row) 

如果明确json_typeof或jsonb_typeof是array，则可以通过以下function将数组转换为行 

不管是什么数组，都返回text行

json_array_elements_text(json)  

jsonb_array_elements_text(jsonb)  

postgres=# select pg_typeof(col),col from (select json_array_elements_text(‘{“a”:”B”,”b”:[1,2,3,4,5,6]}’::json->’b’) col) t; 

 pg_typeof | col 

———–+—– 

 text      | 1 

 text      | 2 

 text      | 3 

 text      | 4 

 text      | 5 

 text      | 6 

(6 rows) 

使用数组构造器，可以将多条记录构造为数组。

postgres=# SELECT array(select json_array_elements_text(‘{“a”:”B”,”b”:[1,2,3,4,5,6]}’::json->’b’));  

     array       

{1,2,3,4,5,6} 

(1 row)  

postgres=# SELECT pg_typeof(array(select json_array_elements_text(‘{“a”:”B”,”b”:[1,2,3,4,5,6]}’::json->’b’)));  



 pg_typeof   

text[] 

(1 row) 

如何转换JSONB数组的类型 

如果想构造int[]，在构造前，可以将行的输出转换为对应的格式，

postgres=# SELECT array(select (json_array_elements_text(‘{“a”:”B”,”b”:[1,2,3,4,5,6]}’::json->’b’))::int );  



     array       

{1,2,3,4,5,6} 

(1 row)  

postgres=# SELECT pg_typeof(array(select (json_array_elements_text(‘{“a”:”B”,”b”:[1,2,3,4,5,6]}’::json->’b’))::int ));  



 pg_typeof   

integer[] 

(1 row)  

编写JSON数组转换为SQL数组的函数 

可以将以上方法转换为函数来使用，输入json typeof == array的json或jsonb对象，输出text数组。 

转换jsonb, json array to text array

CREATE OR REPLACE FUNCTION json_arr2text_arr(_js jsonb) 

   RETURNS text[] AS 

$func$ 

SELECT ARRAY(SELECT jsonb_array_elements_text(_js)) 

$func$ 

LANGUAGE sql IMMUTABLE;  

CREATE OR REPLACE FUNCTION json_arr2text_arr(_js json) 

   RETURNS text[] AS 

$func$ 

SELECT ARRAY(SELECT json_array_elements_text(_js)) 

$func$ 

LANGUAGE sql IMMUTABLE; 

转换jsonb, json array to int array

CREATE OR REPLACE FUNCTION json_arr2int_arr(_js jsonb) 

   RETURNS int[] AS 

$func$ 

SELECT ARRAY( SELECT (jsonb_array_elements_text(_js))::int ) 

$func$ 

LANGUAGE sql IMMUTABLE;  

CREATE OR REPLACE FUNCTION json_arr2int_arr(_js json) 

   RETURNS int[] AS 

$func$ 

SELECT ARRAY( SELECT (json_array_elements_text(_js))::int ) 

$func$ 

LANGUAGE sql IMMUTABLE; 

例子

postgres=# select col, pg_typeof(col) from (select json_arr2text_arr(c1->’f’) col from t3) t; 

    col    | pg_typeof 

———–+———– 

 {1,2,3,4} | text[] 

(1 row)  

postgres=# select col, pg_typeof(col) from (select json_arr2int_arr(c1->’f’) col from t3) t; 

    col    | pg_typeof 

———–+———– 

 {1,2,3,4} | integer[] 

(1 row)  

postgres=# select col, pg_typeof(col) from (select json_arr2text_arr(c1->’g’) col from t3) t; 

  col  | pg_typeof 

——-+———– 

 {a,b} | text[] 

(1 row) 

应用场景 

例如业务系统在JSON中存储了一些ARRAY，这些ARRAY通常会包括一些全包含，全不包含，相交等查询，达到查询的目的。

这里就需要用到数组的包含，相交，不相干操作符来判断，那就会用到前面提到的数组的转换需求。

例子

例如JSON存储的是乐高积木的各属性。

JSON某个KEY存储的数组代表乐高积木对应型号的小零件部件号清单，然后用户需要查询哪些积木型号包含了指定零件编号，这里涉及的就是全包含的查询。

包含’a’零件

postgres=# select * from t3 where json_arr2text_arr(c1->’g’) @> array[‘a’];  



                                                 c1                                                    

{“a”: “v”, “b”: 12, “c”: {“ab”: “hello”}, “d”: 12.3, “e”: true, “f”: [1, 2, 3, 4], “g”: [“a”, “b”]} 

(1 row) 

同时包含’a’,’c’零件

postgres=# select * from t3 where json_arr2text_arr(c1->’g’) @> array[‘a’,’c’];  



 c1   

(0 rows) 

同时包含1,2零件

postgres=# select * from t3 where json_arr2int_arr(c1->’f’) @> array[1,2];  



                                                 c1                                                    

{“a”: “v”, “b”: 12, “c”: {“ab”: “hello”}, “d”: 12.3, “e”: true, “f”: [1, 2, 3, 4], “g”: [“a”, “b”]} 

(1 row) 

同时包含1,6零件

postgres=# select * from t3 where json_arr2int_arr(c1->’f’) @> array[1,6];  



 c1   

(0 rows) 

包含1或6零件

postgres=# select * from t3 where json_arr2int_arr(c1->’f’) && array[1,6];  



                                                 c1                                                    

{“a”: “v”, “b”: 12, “c”: {“ab”: “hello”}, “d”: 12.3, “e”: true, “f”: [1, 2, 3, 4], “g”: [“a”, “b”]} 

(1 row) 

即不包含1 也不包含6零件

postgres=# select * from t3 where not(json_arr2int_arr(c1->’f’) && array[1,6]);  



 c1   

(0 rows) 

不包含6零件

postgres=# select * from t3 where not(json_arr2int_arr(c1->’f’) && array[6]);  



                                                 c1                                                    

{“a”: “v”, “b”: 12, “c”: {“ab”: “hello”}, “d”: 12.3, “e”: true, “f”: [1, 2, 3, 4], “g”: [“a”, “b”]} 

(1 row) 

如果你不想转换为INT，那么在条件中也不要使用INT数组

postgres=# select * from t3 where not(json_arr2text_arr(c1->’f’) && array[‘6’]);  



                                                 c1                                                    

{“a”: “v”, “b”: 12, “c”: {“ab”: “hello”}, “d”: 12.3, “e”: true, “f”: [1, 2, 3, 4], “g”: [“a”, “b”]} 

(1 row) 

索引 

为了提升这种查询的速度，我们可以这样建立索引。

postgres=# create index idx_t3_1 on t3 using gin (json_arr2text_arr(c1->’f’)); 

CREATE INDEX 

postgres=# set enable_seqscan=off; 

SET 

postgres=# explain select * from t3 where json_arr2text_arr(c1->’f’) && array[‘1’,’6’];



                                  QUERY PLAN                                   

Bitmap Heap Scan on t3  (cost=12.25..16.52 rows=1 width=32) 

   Recheck Cond: (json_arr2text_arr((c1 -> ‘f’::text)) && ‘{1,6}’::text[]) 

   ->  Bitmap Index Scan on idx_t3_1  (cost=0.00..12.25 rows=1 width=0) 

         Index Cond: (json_arr2text_arr((c1 -> ‘f’::text)) && ‘{1,6}’::text[]) 

(4 rows)

postgres=# explain select * from t3 where json_arr2text_arr(c1->’f’) @> array[‘1’,’6’];



                                  QUERY PLAN                                   

Bitmap Heap Scan on t3  (cost=12.25..16.52 rows=1 width=32) 

   Recheck Cond: (json_arr2text_arr((c1 -> ‘f’::text)) @> ‘{1,6}’::text[]) 

   ->  Bitmap Index Scan on idx_t3_1  (cost=0.00..12.25 rows=1 width=0) 

         Index Cond: (json_arr2text_arr((c1 -> ‘f’::text)) @> ‘{1,6}’::text[]) 

(4 rows)