SONObjetc和String Map Bean互转,JSONArray和String List互转

  1 import java.util.ArrayList;
  2 import java.util.HashMap;
  3 import java.util.List;
  4 import java.util.Map;
  5
  6 import com.alibaba.fastjson.JSONArray;
  7 import com.alibaba.fastjson.JSONObject;
  8
  9
 10 public class JSONParse {
 11
 12     public static void main(String[] args) {
 13 //      String str="{‘uid‘:10,‘uname‘:‘张三‘}";
 14 //      System.out.println(stringToJSONObject(str)); //String 转JSONObject
 15
 16 //      HashMap<String, Object> map = new HashMap<String, Object>();
 17 //      map.put("uid", 11);
 18 //      map.put("uname", "张三");
 19 //      System.out.println(mapToJSONObject(map)); //map转JSONObject
 20
 21 //      User user=new User();
 22 //      user.setUid(12);
 23 //      user.setUname("张三");
 24 //      System.out.println(beanToJSONObject(user)); //Bean转JSONObject
 25
 26 //      JSONObject jo=stringToJSONObject(str);
 27 //      System.out.println(jSONObjectToString(jo)); //JSONObject转String
 28
 29 //      Map<String, Object> map=jSONObjectToMap(jo);
 30 //      System.out.println(map);  //JSONObject转Map<Stirng,Object>
 31
 32 //      User u=jSONObjectToBean(jo);
 33 //      System.out.println(u); //JSONObject转Bean
 34
 35
 36         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
 37         Map<String, Object> map = new HashMap<String, Object>();
 38         Map<String, Object> map1 = new HashMap<String, Object>();
 39         map.put("uid", 10);
 40         map.put("uname", "张三");
 41         map1.put("uid", 11);
 42         map1.put("uname", "李四");
 43         list.add(map);
 44         list.add(map1);
 45 //      System.out.println(ListToJsonArray(list)); //List转JSONArray
 46
 47 //      String str=ListToJsonArray(list).toJSONString();
 48 //      System.out.println(stringToJsonArray(str)); //String转JSONArray
 49
 50         JSONArray ja=ListToJsonArray(list);
 51 //      System.out.println(jsonArrayToString(ja));
 52         System.out.println(jsonArrayToList(ja));
 53
 54     }
 55
 56     /**
 57      * 字符串转 JSONObject
 58      * @param string
 59      * @return JSONObject
 60      */
 61     public static JSONObject stringToJSONObject(String str){
 62         return JSONObject.parseObject(str);
 63     }
 64
 65     /**
 66      * Map转 JSONObject
 67      * @param string
 68      * @return JSONObject
 69      */
 70     public static JSONObject mapToJSONObject(Map<String, Object> map){
 71         JSONObject jo=new JSONObject();
 72         jo.putAll(map);
 73         return jo;
 74     }
 75
 76     /**
 77      * Bean转 JSONObject
 78      * @param string
 79      * @return JSONObject
 80      */
 81     public static JSONObject beanToJSONObject(User user){
 82         return (JSONObject) JSONObject.toJSON(user);
 83     }
 84
 85     /**
 86      * JSONObject转字符串
 87      * @param JSONObject
 88      * @return string
 89      */
 90     public static String jSONObjectToString(JSONObject jo){
 91         return jo.toJSONString();
 92     }
 93
 94     /**
 95      * JSONObject转Map
 96      * @param JSONObject
 97      * @return string
 98      */
 99     public static Map<String, Object> jSONObjectToMap(JSONObject jo){
100         return JSONObject.toJavaObject(jo, Map.class);
101     }
102
103     /**
104      * JSONObject转Bean
105      * @param JSONObject
106      * @return string
107      */
108     public static User jSONObjectToBean(JSONObject jo){
109         return JSONObject.toJavaObject(jo, User.class);
110     }
111
112
113     /**
114      * String转JSONArray
115      * @param String
116      * @return JSONArray
117      */
118     public static JSONArray stringToJsonArray(String str){
119         return JSONArray.parseArray(str);
120     }
121
122
123     /**
124      * list转JSONArray
125      * @param list
126      * @return JSONArray
127      */
128     public static JSONArray ListToJsonArray(List<Map<String, Object>> list){
129         JSONArray ja=new JSONArray();
130         ja.addAll(list);
131         return ja;
132     }
133
134     /**
135      * JSONArray转 String
136      * @param JSONArray
137      * @return String
138      */
139     public static String jsonArrayToString(JSONArray ja){
140         return ja.toJSONString();
141     }
142
143     /**
144      * JSONArray转 List
145      * @param JSONArray
146      * @return List<Map<String, Object>>
147      */
148     public static List<Map<String, Object>> jsonArrayToList(JSONArray ja){
149         return JSONArray.toJavaObject(ja, List.class);
150     }
151 }  

使用的JSON是:fastjson-1.2.3.jar

转载自:http://blog.csdn.net/liangwenmail/article/details/52432443

时间: 2024-08-03 06:58:06

SONObjetc和String Map Bean互转,JSONArray和String List互转的相关文章

总结的一些json格式和对象/String/Map/List等的互转工具类

原文:总结的一些json格式和对象/String/Map/List等的互转工具类 源代码下载地址:http://www.zuidaima.com/share/1550463691508736.htm 总结的一些json格式和对象/String/Map/List等的互转工具类,有需要的可以看看,需要引入jackson-core-asl-1.7.1.jar.jackson-jaxrs-1.7.1.jar.jackson-mapper-asl-1.7.1.jar这三个jar包 package com.

Gson基本操作,JsonObject,JsonArray,String,JavaBean,List互转

http://www.cnblogs.com/jianyungsun/p/6647203.html http://blog.csdn.net/pg_guo/article/details/51083502 String.JsonObject.JavaBean 互相转换 User user = new Gson().fromJson(jsonObject, User.class); User user = new Gson().fromJson(string, User.class); Strin

Netscaler数据索引String Map与Pattern Set的区别

Netscaler中建立索引或子集无疑是解耦前后关联事务的非常好的思路,可以大幅度的减少后期策略的修改,简化管理,降低用户的使用门槛.即便是不常操作netscaler但又偶尔有改动策略需求的管理员,你只要告诉他改一个地方的文件即可完成多条策略的更新工作,而不需要他理解复杂的策略逻辑关系.在netscaler中有data set.pattern set.string map等方式来提供不同目的的属性子集以供操作.我们这里先讨论其中两个与字符串相关的类型.以下是手册中对这两个参数的描述:String

字符串string和内存流MemoryStream及比特数组byte[]互转

定义string变量为str,内存流变量为ms,比特数组为bt 1.字符串转比特数组 (1)byte[] bt=System.Text.Encoding.Default.GetBytes("字符串"); (2)byte[] bt=Convert.FromBase64String("字符串"); 2.字符串转流 (1)MemoryStream ms=new MemoryStream(System.Text.Encoding.Default.GetBytes("

*389. Find the Difference (string + map(26)) read problems carefully

Given two strings s and t which consist of only lowercase letters. String t is generated by random shuffling string s and then add one more letter at a random position. Find the letter that was added in t. Example: Input: s = "abcd" t = "ab

在拦截器中获取请求参数,[Ljava.lang.String; cannot be cast to java.lang.String报错

Map<String,Object> parametersmap=invocation.getInvocationContext().getParameters();//获取请求参数                Set<String> parametersset=parametersmap.keySet();                for(String key:parametersset){ System.out.println(key+":"+par

PPI | protein-protein interaction | 蛋白互作分析 | gene interaction | 基因互作

前言 做RNA-seq基因表达数据分析挖掘,我们感兴趣的其实是“基因互作”,哪些基因影响了我们这个基因G,我们的基因G又会去影响哪些基因,从而得到基因调控的机制. 直觉确实是很明确的,但是细节处却有很多问题. 我们讨论的到底是基因表达的互作,还是基因产物的互作? ------------ 对于蛋白编码基因,它翻译产生蛋白,如果此蛋白不参与转录过程,理论上不可能会影响另一个基因的表达,那也就不存在基因表达的互作的,它们的基因表达被很好的隔离起来了,相互独立,互不影响. 但现在鉴定出了很多调控基因或

【java】Date与String之间的转换:java.text.SimpleDateFormat、public Date parse(String source) throws ParseException和public final String format(Date date)

1 package 日期日历类; 2 3 import java.text.ParseException; 4 import java.text.SimpleDateFormat; 5 import java.util.Date; 6 7 public class TestDate { 8 public static void main(String[] args) { 9 Date date=new java.util.Date(); 10 System.out.println(date);/

string 构造函数,=,整数 赋值给 string 引起的 坑

对string 理解构造和赋值理解不清引起的错误. 起因: string a; int i=1; a=i;//不报错,不警告 int c=330;//大于256 a=c;//不警告,不报错 a=330;//warning: overflow in implicit constant conversion string str=3;// error: invalid conversion from 'int' to 'const char*' string str(3);// error: inv