java_树形结构json数据_replaceAll_树状json数据_mznpdjw的博客

1.数据结构Topology如下

package entity;
import com.alibaba.fastjson.annotation.JSONField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Topology {
    private String id;
    private Integer status;
    private String address;
    @JSONField(name = "child_list")
    private List<Topology> childList;
2.递归处理
 
     * 递归实现
     * @param topology 树形拓扑数据
     * @return 处理后的数据
    private Topology modifyStateByRecursion(Topology topology) {
        topology.setStatus(topology.getStatus() == 3 ? 1 : 0);
        if (topology.getChildList() != null && topology.getChildList().size() != 0) {
            for (Topology sonTopology : topology.getChildList()) {
                modifyStateByRecursion(sonTopology);
        return topology;
3.replaceAll使用正则处理
 
	private Topology modifyStateByReplaceAll(String topologyStr) {
        topologyStr = topologyStr.replaceAll("\"status\":[012456789]", "\"status\":0").replace("\"status\":3", "\"status\":1");
        return JSON.parseObject(topologyStr,Topology.class);
   public void test() {
        String s = "{\"id\":\"10081\",\"status\":3,\"address\":\"zg\",\"child_list\":[{\"id\":\"10081\",\"status\":1,\"address\":\"zg\",\"child_list\":null},{\"id\":\"10082\",\"status\":2,\"address\":\"mg\",\"child_list\":[{\"id\":\"10081\",\"status\":5,\"address\":\"zg\",\"child_list\":null}]}]}";
        System.out.println("原数据：===" + s);
        // 新老版本标准兼容，现在需要对里面status做处理，除了3都要改为1，其他都要改为0，再将这个数据保存入库
        // 方法1： 递归解析，然后去设置
        Topology topology= JSON.parseObject(s, Topology.class);
        Topology topologyNew1 = modifyStateByRecursion(topology);
        System.out.println("递归处理后的数据：===" +JSON.toJSONString(topologyNew1));
        // 方法2： 直接当成字符串，正则匹配去改变，推荐使用2
        Topology topologyNew2 = modifyStateByReplaceAll(s);
        System.out.println("正则匹配处理后的数据：===" +JSON.toJSONString(topologyNew2));
####原数据####
	"id": "10081",
	"status": 3,
	"address": "zg",
	"child_list": [{
		"id": "10081",
		"status": 1,
		"address": "zg",
		"child_list": null
		"id": "10082",
		"status": 2,
		"address": "mg",
		"child_list": [{
			"id": "10081",
			"status": 5,
			"address": "zg",
			"child_list": null
####递归解析设置处理后的数据####
	"address": "zg",
	"child_list": [{
		"address": "zg",
		"id": "10081",
		"status": 0
		"address": "mg",
		"child_list": [{
			"address": "zg",
			"id": "10081",
			"status": 0
		}],
		"id": "10082",
		"status": 0
	}],
	"id": "10081",
	"status": 1
####replaceAll正则处理后的数据####
	"address": "zg",
	"child_list": [{
		"address": "zg",
		"id": "10081",
		"status": 0
		"address": "mg",
		"child_list": [{
			"address": "zg",
			"id": "10081",
			"status": 0
		}],
		"id": "10082",
		"status": 0
	}],
	"id": "10081",
	"status": 1
                    背景版本兼容性问题，需要对树形结构的数据的某一属性值特殊处理，想到了两种处理方式，一种递归解析设置，另一种replaceAll正则匹配替换，最终还是选择使用replaceAll，原来replaceAll这么好用。。解决步骤1.数据结构Topology如下package entity;import com.alibaba.fastjson.annotation.JSONField;import lombok.AllArgsConstructor;import lombok.Data;impo
import net.sf.ezmorph.object.DateMorpher;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.util.JSONUtils;
public class Jsontest {
	 * @param args
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		JSONObject jsonObj = new JSONObject();
		jsonObj.put("name", "hzj");
		jsonObj.put("sex", "female");
		System.out.println(jsonObj);
	public static Object jsonToBean(String jsonString, Class cla) {
		JSONObject jsonObj = null;
		try {
			setDateFormat2Java();
			jsonObj = JSONObject.fromObject(jsonString);
		} catch (Exception ex) {
			ex.printStackTrace();
		return JSONObject.toBean(jsonObj, cla);
	public static Object jsonToBean(String jsonString, Class cla, Map map) {
		JSONObject jsonObj = null;
		try {
			setDateFormat2Java();
			jsonObj = JSONObject.fromObject(jsonString);
		} catch (Exception ex) {
			ex.printStackTrace();
		return JSONObject.toBean(jsonObj, cla, map);
	public static Object[] jsonToArray(String jsonString, Class cla) {
		Object[] arrObj = null;
		try {
			setDateFormat2Java();
			JSONArray array = JSONArray.fromObject(jsonString);
			arrObj = new Object[array.size()];
			for (int i = 0; i < array.size(); i++) {
				JSONObject jsonObject = array.getJSONObject(i);
				arrObj[i] = JSONObject.toBean(jsonObject, cla);
		} catch (Exception ex) {
			ex.printStackTrace();
		return arrObj;
	public static Object[] jsonToArray(String jsonString, Class cla, Map map) {
		Object[] arrObj = null;
		try {
			setDateFormat2Java();
			JSONArray array = JSONArray.fromObject(jsonString);
			arrObj = new Object[array.size()];
			for (int i = 0; i < array.size(); i++) {
				JSONObject jsonObject = array.getJSONObject(i);
				arrObj[i] = JSONObject.toBean(jsonObject, cla, map);
		} catch (Exception ex) {
			ex.printStackTrace();
		return arrObj;
	public static List jsonToList(String jsonString, Class cla) {
		List list = null;
		try {
			setDateFormat2Java();
			JSONArray array = JSONArray.fromObject(jsonString);
			list = new ArrayList();
			for (Iterator iter = array.iterator(); iter.hasNext();) {
				JSONObject jsonObject = (JSONObject) iter.next();
				list.add(JSONObject.toBean(jsonObject, cla));
		} catch (Exception ex) {
			ex.printStackTrace();
		return list;
	public static List jsonToList(String jsonString, Class cla, Map map) {
		List list = null;
		try {
			setDateFormat2Java();
			JSONArray array = JSONArray.fromObject(jsonString);
			list = new ArrayList();
			for (Iterator iter = array.iterator(); iter.hasNext();) {
				JSONObject jsonObject = (JSONObject) iter.next();
				list.add(JSONObject.toBean(jsonObject, cla, map));
		} catch (Exception ex) {
			ex.printStackTrace();
		return list;
	public static Map jsonToMap(String jsonString) {
		Map map = null;
		try {
			setDateFormat2Java();
			JSONObject jsonObject = JSONObject.fromObject(jsonString);
			map = new HashMap();
			for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
				String key = (String) iter.next();
				map.put(key, jsonObject.get(key));
		} catch (Exception ex) {
			ex.printStackTrace();
		return map;
	public static Object[] jsonToArray(String jsonString) {
		JSONArray jsonArray = JSONArray.fromObject(jsonString);
		return jsonArray.toArray();
	public static void setDateFormat2Java() {
		JSONUtils.getMorpherRegistry().registerMorpher(
				new DateMorpher(new String[] { "yyyy-MM-dd",
						"yyyy-MM-dd HH:mm:ss" }));
//targetArr 目标数组     rootObj   根节点 
	public  JSONObject getJsonTree(JSONArray targetArr, JSONObject rootObj) {
		JSONArray tempArr = new JSONArray();
		// 筛选出当前根节点下的数组
		for (int i = 0; i < targetArr.size(); i++) {
			if (targetArr.getJSONObject(i).
				JSON to Java Tree Model Example
Jackson提供了一个TreeNode类： com.fasterxml.jackson.databind.JsonNode。ObjectMapper提供了一个方法将JSON转换为一个以JsonNode作为根节点的TreeNode。这和DOM 节点在XML DMO树中比较相似。下面的栗子展示了从JSON字符串构建一棵树的过程；
pub...
export function InitializationTree(data = []) {
    if (!data || !Array.isArray(data)) {
        return;
    // 循环遍历json数据
    for (let i = 0; i < data.length; i++) 
String str = "Hello World";
str = str.replaceAll("World", "Java");
System.out.println(str); // "Hello Java"
这里把"World"替换成了"Java"
<h3>回答2：</h3><br/>Java中的replaceAll()方法是用来替换字符串中的所有匹配项。正则表达式在此方法中起着关键作用，可以准确地查找匹配项并进行替换。
正则表达式是一种用于匹配文本的模式。在Java中使用正则表达式，需要利用java.util.regex包中的类和方法。正则表达式的基本语法如下：
1. 字符类：[]，表示匹配在方括号内的任意一个字符。例如：[abc]表示匹配a、b或c中的任意一个字符。
2. 范围：-，表示匹配指定范围内的任意一个字符。例如：[a-z]表示匹配所有小写字母。
3. 表达式：.，表示匹配任意一个字符。
4. 特殊字符：\，表示转义字符。例如：\d表示匹配任意一个数字。
5. 次数：*、+、？、{n}、{n,}、{n,m}，表示匹配次数。例如：a*表示匹配任意个a（包括0个）；a+表示匹配至少一个a；a?表示匹配0个或1个a；a{n}表示匹配n个a；a{n,}表示匹配至少n个a；a{n,m}表示匹配n到m个a。
在Java中，使用正则表达式来替换字符串中的内容，需要使用replaceAll()方法。该方法接受两个参数，第一个参数是正则表达式，第二个参数是替换的内容。
例如，要将文本字符串中的所有空格替换为下划线，可以使用如下代码：
String str = "This is a test string.";
String newStr = str.replaceAll("\\s", "_");
在这个例子中，"\\s"表示空格字符，使用"\\"是因为在Java中"\"是一个转义字符。
在实际应用中，正则表达式的使用不仅限于替换字符串中的内容，还可以用来验证输入的数据格式、匹配URL、提取邮件地址等等。掌握正则表达式的基本语法和使用方法，对于Java程序员来说是非常重要的技能之一。   
<h3>回答3：</h3><br/>在Java中，我们使用replaceAll()方法来替换字符串中的指定字符或字符串。正则表达式在其中也起到了非常重要的作用。
正则表达式是一组特殊字符和语法，它可以用来定义一些规则，用于匹配、查找、替换字符串中的特定模式。在Java中使用正则表达式的方法非常多，比如matches()、split()、replace()、replaceAll()等。
我们先来看一下replaceAll()方法的基本用法：
String str = "abcccdefg";
String replacedStr = str.replaceAll("c", "C");
System.out.println(replacedStr);
结果为abCCCdefg。
在上面的代码中，我们定义了一个字符串变量str，然后使用replaceAll()方法将字母c替换为字母C，并赋值给了另一个字符串变量replacedStr。最后输出replacedStr的值。
使用replaceAll()方法时，正则表达式也就相应地变得非常重要了。下面是一些正则表达式示例：
1. 将字符串中的所有空格替换成逗号：
String str = "This is a test string";
String replacedStr = str.replaceAll("\\s+", ",");
System.out.println(replacedStr);
结果为This,is,a,test,string。
在上面的代码中，我们使用了正则表达式\\s+来匹配一个或多个连续的空格，然后将其替换成了逗号。
2. 将字符串中的所有数字替换成星号：
String str = "my phone number is 123-456-7890";
String replacedStr = str.replaceAll("\\d", "*");
System.out.println(replacedStr);
结果为my phone number is ***-***-****。
在上面的代码中，我们使用了正则表达式\\d来匹配任意数字，然后将其替换成了星号。
3. 将字符串中的第一个单词替换成另一个单词：
String str = "The quick brown fox jumps over the lazy dog";
String replacedStr = str.replaceFirst("\\b\\w+\\b", "A");
System.out.println(replacedStr);
结果为A quick brown fox jumps over the lazy dog。
在上面的代码中，我们使用了正则表达式\\b\\w+\\b来匹配第一个完整的单词，然后将其替换成了字母A。
需要注意的是，在正则表达式中，一些特殊字符需要转义，比如在某些情况下，我们需要匹配一个点号(.)，那么正则表达式应该写成"\\."。
总之，通过学习和掌握正则表达式，在Java中使用replaceAll()方法可以更加灵活和方便，能够帮助我们更好地处理和操作字符串。