json过滤集合_java json取集合某个元素

❶ 如何将json字符串包含多个list集合嵌套加到实体对象中

用fastjson来解析，其有个工具类JSON可以直接把字符串解析为JSONObject，如果你有对应的java类，还可以直接解析为Java对象用fastjson来解析，其有个工具类JSON可以直接把字符串解析为JSONObject，如果你有对应的java类，还可以直接解析为Java对象用fastjson来解析，其有个工具类JSON可以直接把字符串解析为JSONObject，如果你有对应的java类，还可以直接解析为Java对象

❷ 怎么用json转list的集合对象

1. 简单的手动放置键值对到JSONObject，然后在put到JSONArray对象里
List<Article> al = articleMng.find(f);
System.out.println(al.size());
HttpServletResponse hsr = ServletActionContext.getResponse();
if(null == al){
return ;
}
for(Article a : al){
System.out.println(a.getId()+a.getDescription()+a.getTitle());
}
JSONArray json = new JSONArray();
for(Article a : al){
JSONObject jo = new JSONObject();
jo.put("id", a.getId());
jo.put("title", a.getTitle());
jo.put("desc", a.getDescription());
json.put(jo);
}
try {
System.out.println(json.toString());
hsr.setCharacterEncoding("UTF-8");
hsr.getWriter().write(json.toString());
} catch (IOException e) {
e.printStackTrace();
}
复制代码
上述代码JSONArray是引入的org.json.JSONArray包

而用net.sf.json包下JSONArray的静态方法：fromObject(list) 这是网上大多是都是直接用此方法快捷转换JSON，但是对于Hibernate级联操作关联的对象，这个方法就会报错，如果将映射文件中的级联配置去掉就行了。

另外对于list的要求就是其中的元素是字符串或对象，否则JSON不知道你想要的是什么数据。

<many-to-one name="cmsent" column="comment_tid" class="com.fcms.cms.entity.CmsComment"
not-null="false" cascade="delete">
但是级联操作毕竟还是得存在，否则以后数据冗余、多余。

解决方法就是：JSONArray subMsgs = JSONArray.fromObject(object, config);

JsonConfig config = new JsonConfig();
config.setJsonPropertyFilter(new PropertyFilter() {
public boolean apply(Object arg0, String arg1, Object arg2) {
if (arg1.equals("article") ||arg1.equals("fans")) {
return true;
} else {
return false;
}
}
});
复制代码
说明：提供了一个过滤作用，如果遇到关联的对象时他会自动过滤掉，不去执行关联关联所关联的对象。这里我贴出我hibernate中的配置关系映射的代码帮助理解：


<many-to-one name="article" class="com.fcms.nubb.article" column="article_id"/>


<set name="subMessages" table="sub_message" inverse="true" cascade="all" lazy="false" order-by="date asc">
<key column="theme_id" />
<one-to-many class="bbs.po.SubMessage" />
</set>

总结：
1. JSONArray subMsgs = JSONArray.fromObject(subMessages, config);其中config是可选的，当出现上面的情况是可以配置config参数，如果没有上面的那种需求就可以直接使用fromObject(obj)方法，它转换出来的就是标准的json对象格式的数据，如下：

{["attr", "content", ...}, ...]}

2. JSONObject jTmsg = JSONObject.fromObject(themeMessage, config);这是专门用来解析标准的pojo，或者map对象的，pojo对象的格式就不用说了，map的形式是这样的{"str", "str"}。

----------------------------------------------------------- 分割 -------------------------------------------------------------------------------------------

package com.nubb.bean;

import java.io.Serializable;

public class Person implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
private String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}

}

package com.nubb.test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.nubb.bean.Person;

public class JSONSerializer {
private static final String DEFAULT_CHARSET_NAME = "UTF-8";

public static <T> String serialize(T object) {
return JSON.toJSONString(object);
}

public static <T> T deserialize(String string, Class<T> clz) {
return JSON.parseObject(string, clz);
}

public static <T> T load(Path path, Class<T> clz) throws IOException {
return deserialize(
new String(Files.readAllBytes(path), DEFAULT_CHARSET_NAME), clz);
}

public static <T> void save(Path path, T object) throws IOException {
if (Files.notExists(path.getParent())) {
Files.createDirectories(path.getParent());
}
Files.write(path,
serialize(object).getBytes(DEFAULT_CHARSET_NAME),
StandardOpenOption.WRITE,
StandardOpenOption.CREATE,
StandardOpenOption.TRUNCATE_EXISTING);
}

public static void main(String[] args) {
Person person1 = new Person();
person1.setAddress("address");
person1.setAge(11);
person1.setName("amao");

Person person2 = new Person();
person2.setAddress("address");
person2.setAge(11);
person2.setName("amao");

List<Person> lp = new ArrayList<Person>();
lp.add(person1);
lp.add(person2);
System.out.println(serialize(lp));
}

}

输出：

[{"address":"address","age":11,"name":"amao"},{"address":"address","age":11,"name":"amao"}]

❸ 怎么把list集合转换成json

❹ json多层集合嵌套解析求助

首先楼上说的部分是对的。那么我先假设你已经获得了这个字符串，将之定义为jsonString.
JSONObject jsonObject = new JSONObject(jsonString);
然后，根据嵌套的种类，可以确定下一步如何取值。根据你的情况来看。应该是：
String user_get_response = jsonObject.getString("user_get_response");
JSONObject user_get_response_obj = new JSONObject(user_get_response);
这是针对第一层嵌套的。
一层一层的取下去就好。如果是数组类型的，就用JSONArray来接收。
JSONArray jsonArray = new JSONArray(jsonObject.getString("xxx"));
总之就是由外到内去解析就好

❺ java json取集合某个元素

首先你的这个json串就有问题，修改下才能解析，解析方法如下
JSONObject log=jsonObject.getJSONObject("第一级Object");
JSONArray jsonArray = log.getJSONArray("Object中的array");
JSONObject pages = jsonArray.getJSONObject(0); //从jsonArray中解析第一个Object
JSONObject pageTimings=pages.getJSONObject("继续解析object");
String onContentLoad=pageTimings.getString("onContentLoad"); //得到想要的值
把{}大括号扩起来的看成是object，如果有名字就根据名字来解析，如果没名字就根据序号来解析，上面的代码两种情况均有涉及，请注意参考与更改变量名。[]扩起来的看成数组，用getArray解析，同样可以用名字或序号解析

❻ 如何将json数据转化为一个类的集合

您好
（。这个list集合里有2900个对象，每个对象对应一个实体类，里面有19个属性。）
这最后一句话看出，你现在的情绪已经崩溃了！！

不管数据在多，它和三条数据的存在是一个道理，你用的是循环多少数据又有什么关系。

不知道你现在是取不到这个list ，还是不知道应该怎么把这个list 放到 struts2的iterator 里面

❼ js怎样取出json对象集合的前几条记录，或者说第n到第m条记录，然后转化为另一个json对象集合

直接当数组一样操作就行了啊
如果用jquery的话，有现成的过滤数组的函数

❽ 如何从文件中读取JSON使用JSON净C 集合.问题，怎么解决

用C语言获取JSON中的数据的方法是使用 CJSON。
以下简单介绍用CJSON的思路及实现：

❾ Resconfig.json什么意思

JSONSerializer的toJSON方法可以把参数指定的对象转换成一个JSON接口的对象，如果这个对象是一个String对象，那么这个方法还会校验这个String对象是否是一个合法的JSON字符串（即是否符合JavaScript的语法）。对于一般JavaBean（必须是标准的具有setter\getter的JavaBean）的转换就是按照属性值对的方式生成JS对象，缺省的情况下Map会转换成对象，而List和数组会转换为数组。
JSONSerializer的toJava方法可以把JSON接口的对象转换为JavaBean对象，缺省情况下，JSON接口的对象会被转换为net.sf.ezmorph.bean.MorphDynaBean对象，所有基本类型（基本类型包装类）、数组和String类型的属性都会被准确的装换，而其他类型（如Map等）都会被缺省的转换为net.sf.ezmorph.bean.MorphDynaBean对象。
以上是使用JSONSerializer的缺省转换函数（一个参数）进行转换的结果，如果使用两个参数的转换函数（第二个参数为JsonConfig对象），则会按照JsonConfig的配置进行转换。toJSON转换时的配置：
setJsonPropertyFilter属性过滤，用于处理那些属性被过滤掉而不被转化换为JSON，嵌套引用的Bean的属性也可以被过滤。如下：
/* 使用属性过滤器 */
myBeanJc.setJsonPropertyFilter(new PropertyFilter() {
@Override
public boolean apply(Object o, String n, Object v) {
if (o instanceof MyBean && n.equals("beanMap")) {
MyBean mb = (MyBean) o;
if (mb.getBeanMap().keySet().isEmpty())
return true;
} else if (o instanceof MyInnerBean && n.equals("attrMap")) {
Map<String, String> m = (Map<String, String>) v;
if (m.keySet().isEmpty())
return true;
} else
;
return false;
}

});
这个例子使用了匿名类的方式实现了一个自定义的属性过滤器，其实就是覆盖apply方法，这个方法的返回值决定是否把此属性过滤掉（true表示过滤掉此属性而不转化到JSON中）。json-lib本身提供一些实现了PropertyFilter的属性过滤器类供我们使用，如AndPropertyFilter, CompositePropertyFilter, FalsePropertyFilter, MappingPropertyFilter, NotPropertyFilter, OrPropertyFilter, TruePropertyFilter等，有兴趣的话可以逐个试验。
registerJsonBeanProcessor注册JsonBeanProcessor，使用JsonBeanProcessor处理bean对象到JSON接口对象的转换，它给我们提供了自定义的bean到JSON的转换的接口，通过注册自定义的JsonBeanProcessor我们可以按照自己的想法把bean转化成我们想要的样子。如下：
/* 使用JsonBeanProcessor处理bean对象到json对象的转换 */
myBeanJc.registerJsonBeanProcessor(MyInnerBean.class,
new JsonBeanProcessor() {

@Override
public JSONObject processBean(Object o, JsonConfig jc) {
return JSONObject
.fromObject("{title : 'I am an inner bean!'}");
}
});
这个例子就给MyInnerBean注册了一个自定义的JsonBeanProcessor，使用匿名类的方式实现了processBean方法，processBean方法返回的JSON对象就是在进行bean到JSON转化时MyInnerBean对象转化成的JSON对象。
setJsonBeanProcessorMatcher可以设置用于匹配JsonBeanProcessor的自定义的匹配器JsonBeanProcessorMatcher，通过实现JsonBeanProcessorMatcher的getMatch方法（这个方法有两个参数，第一个是需要匹配的对象的Class对象，第二个参数是所有注册了JsonBeanProcessor的Class对象的集合），返回一个Calss对象，转换器会用以返回的Class对象注册的JsonBeanProcessor处理这个类的转换。如下：
/* 设置处理过程的注册类匹配器 */
myBeanJc
.setJsonBeanProcessorMatcher(new JsonBeanProcessorMatcher() {

@Override
public Object getMatch(Class c, Set s) {
if (c.equals(MyInnerBean.class))
return innerClzz.class;
return c;
}
});
这个例子使用匿名类实现了一个自定义的JsonBeanProcessorMatcher，覆盖了getMatch方法，它表示在bean到JSON的转化过程中，如果我们要处理的类是MyInnerBean类，则返回innerClzz类，这时就会使用innerClzz注册的JsonBeanProcessor来处理这个MyInnerBean，如果我们没有为innerClzz注册JsonBeanProcessor，则使用缺省的转化过程处理（属性值对的方式）。
registerJsonValueProcessor注册JsonValueProcessor，使用JsonValueProcessor处理Bean对象的属性值的转换，这里是为指定的数据类型注册JsonValueProcessor。如下：
/* 使用JsonValueProcessor处理Bean对象的属性值的转换 */
myBeanJc.registerJsonValueProcessor(Double.class,
new JsonValueProcessor() {

@Override
public Object processArrayValue(Object arg0,
JsonConfig arg1) {
return null;
}

@Override
public Object processObjectValue(String k, Object v,
JsonConfig arg2) {
if (k.equals("dblVal"))
return Double.valueOf(v.toString())
.doubleValue()
* 100 + "%";
else
return v;
}

});
这个例子就是为双精度浮点型注册了一个JsonValueProcessor，需要我们覆盖两个方法，从名称就能明白它们是分别处理数组和对象中的指定数据类型的方法。在这里我们把属性dblVal的双精度浮点值转化为表示百分比的字符串，对于其他的双精度浮点值不做处理。
注册处理过程的方法都有其对应的反注册（unregisterXxProcessor）方法，同时还提供了查找这些处理过程的方法（findXxProcessor）。
setExcludes设置不作转换的属性名称，getExcludes可以返回设置的属性名称字符串数组，而getMergedExcludes可以返回所有不做转换的属性集合，包括setExcludes设置的属性名称。
setJavaIdentifierTransformer设置使用何种Java标识符的转换器，没太看懂，JavaIdentifierTransformer倒是挺好理解，可是这个转换功能如何使用，在什么时候使用呢？
setArrayMode设置数组的转换模式，也不会用。
setRootClass设置根对象目标类，也就是从JSON接口对象转换为bean时得到的对象的Java类，如果不设置的话，就转换为MorphDynaBean。
setNewBeanInstanceStrategy用于设置对象实例化时使用的策略，缺省的是使用Class的newInstance方法。从JSON接口对象转换成JavaBean对象时首先应用该策略，然后才会用JSON接口对象的内容为实例赋值。如下：
/* 设置对象实例化策略 */
myBeanJc.setNewBeanInstanceStrategy(new NewBeanInstanceStrategy() {

@Override
public Object newInstance(Class c, JSONObject jo)
throws InstantiationException, IllegalAccessException {
Object o;
if (c.equals(MyInnerBean.class)) {
String t = "Recovered " + jo.get("title");
jo.put("title", t);
o = new MyInnerBean();
}else
o = c.newInstance();
return o;
}
});
这个例子中，使用匿名类的方式覆盖newInstance方法，如果是MyInnerBean类则使用无参构造函数实例化对象，其他情况下使用缺省的实例化方式。因为从JSON接口对象转换成JavaBean对象时首先应用该策略，然后才会用JSON接口对象的内容为实例赋值，所以在这里为实例化对象赋值是没有意义的，如果想改变最后的bean的属性值，可以通过修改JSON对象的属性值来实现。
setClassMap应该是用于JSON和XML转换的，有待进一步研究。
此外还有其他相对简单的转换过程配置选项的功能，比较容易理解和使用，类似于开关量。如：disableEventTriggering() ，enableEventTriggering()等等。

❿ struts2 json plugin includeProperties怎么过滤Set集合

includeProperties 是包括，可以使用 excludeProperties 排除。。。。。。。。。

参考

@Result(name = Action.SUCCESS, type = "json", params = {

"excludeProperties","pageList\\.\\list[\\d+\\]\\.tbGrpInfo\\.(tbGrpEmps.*|tbGrpSets.*|tbGrpDepts.*){1}",

//过滤的值(我用的是hibernate，这里是过滤集合中tbGrpInfo这个对象，但是tbGrpInfo个对象包含了
tbGrpEmps,tbGrpSets,tbGrpDepts对象，因此都需要过滤,{1}这个表示只要有其中一个就过滤掉)
"includeProperties", "success,msg,pageList.*" //返回的值
}),

导航:首页 > 净水问答 > json过滤集合

json过滤集合

与json过滤集合相关的资料