java实现一个JSON字符串处理工具，轻量级

最新推荐文章于 2024-04-29 06:29:47 发布
最新推荐文章于 2024-04-29 06:29:47 发布
阅读量531 收藏
点赞数
分类专栏： java 算法学习 文章标签： Java 正则 解析 JSON Parser
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34820292/article/details/88772449
版权

突发奇想要造一个轮子，处理JSON字符串

特点：

1. 能够正确处理括号嵌套，但是可能会受到json中嵌套的特殊带有干扰性的单括号影响，有时间可结合第2点完善。

2. 能够正确处理带有转义引号的字符串。

3. 对json的键值对定位处理类似于新版MySQL中的处理方式“attr1.$2.subattr2”，这里$2代表找这个数组第二个

4. JSON的定义：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
完整代码如下：


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Json {
	// json的六种value
	public static final int TYPE_OBJ = 1;
	public static final int TYPE_ARR = 2;
	public static final int TYPE_STR = 3;
	public static final int TYPE_NUM = 4;
	public static final int TYPE_BOL = 5;
	public static final int TYPE_NUL = 6;
	
	// json的六种value的匹配正则
	public static final String RE_OBJ = "\\s*(\\{(.*)\\})\\s*"; // 匹配Object : {}，但是嵌套会出错
	public static final String RE_ARR = "\\s*(\\[(.*?)\\])\\s*"; // 匹配数组[]，但是嵌套会出错
	public static final String RE_STR = "\\s*((((?<!\\\\)\")(.*?)((?<!\\\\)\")))\\s*";// 匹配字符串，且能正确处理转义引号
	public static final String RE_NUM = "\\s*((-?(\\d+\\.)?\\d+))\\s*"; // 匹配任意数字
	public static final String RE_BOL = "\\s*(((true)|(True)|(TRUE)|T|(false)|(False)|(FALSE)|F))\\s*"; // 匹配Boolean类型
	public static final String RE_NUL = "\\s*(((NULL)|(Null)|(null)|(nul)|(NUL)|(Nul)|(NaN)))\\s*"; // 匹配空值
	
	public int type;
	public Map<String, Json> values;
	public List<Json> array;
	public String self;
	
	public Json() {
		this("{}");
	}

	public Json(String val) {
		super();
		self = val;
		if (test(RE_OBJ, val)) {
			this.type = TYPE_OBJ;
			values = new HashMap<String, Json>();
			String fk, fv;
			int rc = match(val, "{", "}");
			String content = val.substring(1, rc);
			while (content.length() > 0) {
				fk = firstVal(content);
				if (fk == null || fk.equals("{}"))
					break;
//				Log.log(content,fk);
				content = content.substring(fk.length() + 1);
				fv = firstVal(content);
				boolean next = fv.length() < content.length();
				values.put(sv(fk), new Json(fv));
				if (next) {
					content = content.substring(fv.length() + 1);
				} else {
					break;
				}
			}
		} else if (test(RE_ARR, val)) {
			this.type = TYPE_ARR;
			this.array = new ArrayList<Json>();
			int index = match(val, "[", "]");
			String str = val.substring(1, index);
			String fv;
			while (str.length() > 0) {
				fv = firstVal(str);
				boolean next = fv.length() < str.length();
				if (next) {
					str = str.substring(fv.length() + 1);
				} else {
					str = str.substring(fv.length());
				}
				array.add(new Json(fv.trim()));
			}

		} else if (test(RE_STR, val)) {
			this.type = TYPE_STR;
		} else if (test(RE_NUM, val)) {
			this.type = TYPE_NUM;
		} else if (test(RE_BOL, val)) {
			this.type = TYPE_BOL;
		} else if (test(RE_NUL, val)) {
			this.type = TYPE_NUL;
		} else {
			this.type = TYPE_STR;
			this.self = ss(val);
//			this = new Json(ss(val));
//			System.out.println("未能识别的片段:" + val);
		}
	}
	
	// 测试类型
	protected static boolean test(String REG, String str) {
		REG = "^" + REG + "$";
		boolean matches = Pattern.matches(REG, str);
//		System.out.println(matches);
		return matches;
	}
	
	// 获取正则匹配到的某个单元
	protected static String _get(String REG, String str, int which) {
		Matcher matcher = Pattern.compile(REG).matcher(str);
		String res = null;
		if (which < 1) { // 用于测试观察匹配结果
			int groupCount = matcher.groupCount();
			while (matcher.find()) {
				System.out.println("=======");
				for (int i = 0; i <= groupCount; i++) {
					res = matcher.group(i);
					 System.out.println(res);
				}
			}
		} else if (matcher.find()) {
			res = matcher.group(which).trim();
//			 System.out.println(res);
		}
		return res;
	}

	// 计数以得到左边括号的右边对应
	protected static int match(String str, String lt, String rt) {
		int r = 0;
		int i = 0;
		for (; i < str.length() - 1; i++) {
			if (str.substring(i, i + 1).equals(lt)) {
				r++;
			} else if (str.substring(i, i + 1).equals(rt)) {
				r--;
			}
			if (r == 0) {
				return i;
			}
		}
		return i;
	}
	
	// 获取最前面的一个单元的内部
	protected static String firstVal(String str) {
		String re = "null";
		if (str.substring(0, 1).equals("{")) {
			int index = match(str, "{", "}");
			re = str.substring(0, index+1);
		} else if (str.substring(0, 1).equals("[")) {
			int index = match(str, "[", "]");
			re = str.substring(0, index +1);
		} else if(test(RE_STR+".*?",str)){
			re = _get(RE_STR+".*?",str,2);
		} else if(test(RE_NUM+".*?",str)){
			re = _get(RE_NUM+".*?",str,2);
		} else if(test(RE_BOL+".*?",str)){
			re = _get(RE_BOL+".*?",str,2);
		} else if(test(RE_NUL+".*?",str)){
			re = _get(RE_NUL+".*?",str,2);
		}else {
			re = "null";
		}
		return re;
	}

	/**
	 * 返回序列化的JSON字符串
	 */
	@Override
	public String toString() {
		String str = "";
		if (this.type == TYPE_OBJ) {
			str += "{";
			for (String k : values.keySet()) {
				str += ss(k) + ":" + values.get(k) + ",";
			}
			if (str.length() > 1)
				str = str.substring(0, str.length() - 1);
			str += "}";
		} else if (this.type == TYPE_ARR) {
			str += "[";
			for (int i = 0; i < array.size() - 1; i++) {
				str += array.get(i) + ",";
			}
			if (array.size() > 0)
				str += array.get(array.size() - 1);
			str += "]";
		} else {
			str = self;
		}
		return str;
	}
	
	public static String sv(String ss) {
		return ss.substring(1, ss.length()-1);
	}
	public static String ss(String sv) {
		return "\""+sv+"\"";
	}
	public Json get(String mkey) {
		int index = mkey.indexOf('.');
		boolean inarray = mkey.startsWith("$");
		try {
			if(index>0) {
				if(inarray) return this.array.get(Integer.parseInt(mkey.substring(1,index))).get(mkey.substring(index+1));
				return this.values.get(mkey.substring(0,index)).get(mkey.substring(index+1));
			}else {
				if(inarray) return this.array.get(Integer.parseInt(mkey.substring(1,index)));
				return this.values.get(mkey);
			}
		}catch(Exception e) {
			return null;
		}
	}
	
	
	/**
	 * 写入为String
	 * @param mkey
	 * @param value
	 * @return Json
	 * 例如： json.sets("name","张三")
	 */
	public Json sets(String mkey,String value) {
		return this.set(mkey, ss(value));
	}
	
	/**
	 * 写入非String的
	 * @param mkey
	 * @param value
	 * @return Json
	 * 例如： json.sets("age",110)
	 */
	public Json setn(String mkey,int value) {
		return this.set(mkey, String.valueOf(value));
	}
	/**
	 * 不推荐使用
	 * @param mkey
	 * @param value
	 * @return
	 * 例如： json.sets("name","\"张三\"")
	 */
	public Json set(String mkey,String value) {
		int index = mkey.indexOf('.');
		boolean inarray = mkey.startsWith("$");
		if(index>0) {
			if(inarray) {
				this.array.get(Integer.parseInt(mkey.substring(1,index))).set(mkey.substring(index+1),value);
			}
			else {
				this.values.get(mkey.substring(0,index)).set(mkey.substring(index+1),value);
			}
		}else {
			Json json = new Json(value);
			if(inarray) {
				int idx = Integer.parseInt(mkey.substring(1));
				if(this.array==null) this.array = new ArrayList<Json>();
				if(this.array.size()<idx+1) {
					while (this.array.size()<idx+1) {
						this.array.add(new Json(""));
					}
				}
//				System.out.println(this);
				this.array.set(idx,json);
			}
			else {
				this.values.put(mkey,json);
			}
		}
		return this;
	}
	
	/**
	 * 去除最外层的引号
	 * @return
	 */
	public String val() {
		return sv(self);
	}
	
	// TODO 迭代器，用于对{} 和 []的遍历
	public void next(String key) {
		
	}
	
	// TODO 获得 {}key的个数或者[]的个数
	public void length(String mKey) {
		
	}

	// 测试
	public static void main(String[] args) {
//		String val = firstVal("NaNFlase19.80\"12\":\"43\"");
//		System.out.println(val);
//		String demo = "{\"name\":\"tim\",\"age\":24,\"rate\":0.9,\"active\":-0.83,\"major\":[{\"name\":\"数字\",\"score\":100},{\"name\":\"ds\",\"score\":{\"r1\":\"10\",\"r2\":100}}],\"test\":\"[\\\"name\\\",false,[],{\\\"1\\\":\\\"2\\\",\\\"3\\\":\\\"sanjin\\\"},[\\\"name\\\",false,[],{\\\"1\\\":\\\"2\\\",\\\"3\\\":\\\"sanjin\\\"},[]]]\",\"dic\":{}}";
//		Json json = new Json(demo);
//		System.out.println(json);
//		System.out.println(json.get("major.$1.name"));
//		System.out.println(json.set("major.$1.name","大佬"));
//		System.out.println(json.set("test","[]"));
//		Json json = new Json();
//		json.set("cmd", "onlineList_OK");
//		json.set("list", "[]");
//		json.set("list.$0","123");
//		System.out.print(json);
		System.out.println(new Json("{\"clientId\":\"123456\",\"x\":11,\"y\":0,\"step\":0,\"cmd\":\"step\",\"ememyId\":\"13456\",\"isMyWhite\":false} ").get("ememyId"));
	}
}

上述代码运行效果如：

{"major":[{"name":"数字"},{"name":"ds"}],"test":"[\"name\",false,[],{\"1\":\"2\",\"3\":\"sanjin\"},[\"name\",false,[],{\"1\":\"2\",\"3\":\"sanjin\"},[]]]","rate":0.9,"name":"tim","active":-0.83,"age":24}
"ds"
{"major":[{"name":"数字"},{"name":"大佬"}],"test":"[\"name\",false,[],{\"1\":\"2\",\"3\":\"sanjin\"},[\"name\",false,[],{\"1\":\"2\",\"3\":\"sanjin\"},[]]]","rate":0.9,"name":"tim","active":-0.83,"age":24}
{"major":[{"name":"数字"},{"name":"大佬"}],"test":[],"rate":0.9,"name":"tim","active":-0.83,"age":24}

有待实现

  1. 遍历
  2. 反序列化为java对象
tim5wang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSONCoder是一个轻量级Java对象的JSON编码解码库
08-07
JSONCoder 是一个轻量级的通用的 Java 对象序列化和反序列化到 JSON 格式的工具包，类似 Jackson 或者 FastJson。这个库在 eBay 内部广泛使用多年。这并非是要替代其他常用库，主要是解决了一些其他库中不被支持的特别问题。
java 处理 json字符串
chen5287603的专栏
04-16 3708
最近项目中需要解析从远程返回的json字符串。找了网上一些例子，大部分都需要加入第三方的控件。比如GSON.但是第三方插件大部分都需要创建一个java对象用来映射json字符串。对于复杂的json字符串就可以这样搞。但是如果对于比较简单的json字符串，这样处理就有点浪费资源了。如果能够根据KEY值直接返回一个json的value值就是最好的处理方法。于是想到了能不能调用javascript中的e
Java几种常用JSON库性能比较
最新发布
2401_84102759的博客
04-29 1119
小编精心为大家准备了一手资料以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术【附】架构书籍BAT面试的20道高频数据库问题解析Java面试宝典Netty实战算法BATJ面试要点及Java架构师进阶资料e;// 省略getter和setter@Override小编精心为大家准备了一手资料[外链图片转存中…(img-AlpS41X9-1714343376254)]
使用Java操作JSON字符串对象
weixin_34150224的博客
04-04 87
1、如果我们需要实现一个配置管理的功能，那么为每个配置项目增加一个字段既复杂也不利于扩展，所以我们通常使用一个字符串来保存配置项目信息，这里介绍如何使用json的字符串解析来达到刚才说的目的。引入Json需要的类库： import org.json.JSONException;    import org.json.JSONObject;   2、生成一个json对象(可以添加不同类型...
处理Java对象转Json字符串的功能
05-07
接受对象转换为JSON数据格式并且作为字符串输出，map转换json，list转换json
[Java Web]JSON | 一种轻量级数据交换格式
逐梦苍穹的博客
04-03 1044
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它是基于JavaScript语言的一种语法扩展。
java对象转换为json字符串或字符串数组
07-12
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。本文将深入探讨如何使用Java将对象转换为JSON以及字符串数组。 首先，我们需要一个库来处理JSON转换...
Java fastjson解析json字符串实现过程解析
10-14
Fastjson以其高效、轻量级的特点，在Java开发中广泛应用，尤其在Web服务、数据传输以及日志处理等方面。 在开始解析JSON字符串之前，首先需要将Fastjson的依赖添加到项目中。如果你使用的是Maven，可以在pom.xml...
Java实现Json字符串与Object对象相互转换的方式总结
10-17
在Java开发中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于前后端数据传输。本文将详细讲解如何使用Java的五种库：Json-Lib、Org.Json、Jackson、Gson和FastJson来实现JSON字符串与Java...
Json字符串转Java对象和List代码实例
10-15
在Java编程中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛用于服务器与客户端之间的数据传输。当接收到JSON格式的字符串时，我们通常需要将其转换为Java对象以便进一步处理。同样，我们...
详解java生成json字符串的方法
10-20
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。在Java中，有多种库可以帮助我们将Java对象转换为JSON字符串，如org.json和net.sf.json。 1. **org....
json字符串解析工具
08-21
json字符串解析工具
Json处理工具类
10-11
Json字符串处理方法集成大类，帮助开发者快速开发程序。
Java中Json字符串与各种对象互转
05-23
net.sf.json.JSONObject可以处理简单java对象和格式正确的json字符串互相转换。 net.sf.json.JSONArray可以处理复杂的java集合对象和格式正确的json字符串互相转换. 1.json字符串转简单java对象 2.简单java对象转json字符串 3.json字符串转集合对象 4.集合对象转json字符串
Java实现自己的Json解析器
09-02
Java实现自己的Json解析器——Json字符串解析原理 根据提取到的字符，转入不同的解析方法中， 例如字符是t，说明值可能是true，只需检查后面三个字符，如果是r、u、e，则可以直接返回true。 字符是f，说明值可能是false，只需检查后面四个字符，如果是a、l、s、e，则可以直接返回false。 碰到 \"，说明是字符串，在下一个\"出现之前，把扫描出来的字符都当成字符串中的字符，放到一个StringBuilder中去。 碰到 [ 符号，说明是数组了，就需要new一个JsonArray，在下一个 ] 符号出现之前，调用nextObject方法，把解析到的对象都放到这个JsonArray里面去。 碰到 { 符号，说明是JsonObject，就new一个JsonObject，这里每次需要连续调用两次nextObject，第一次结果作为key，第二次结果作为value。放到JsonObject中去。
轻量级JSON解析库Brief-JSON.zip
07-18
轻量级JSON解析库 BriefJSON，追求以最少的代码完成JSON解析及JAVA对象的序列化和反序列化。用户只需把代码文件拷贝到自己的项目中即可使用。采用模块化设计，将JSON序列化与JAVA Bean序列化分成2个包，使用户按需拷贝代码文件。序列化流程JSON TEXT <====jsonserializer=====>Map,List,String,etc. <====beanserializer====>JAVA BEANBeanSerializer.deserializer :把List和Map反序列化为Java Bean;JSONSerializer.serializer :把List和Map序列化为JSON文本;JSONSerializer.deserializer :将JSON文本解析为List和MapBeanSerializer.serializer :把Java Bean序列化为List和MapSeriable :把Java Bean中要序列化的字段用此注解。无此注解的字段将不序列化;ParseException :解析JSON时报错抛出的异常。 标签：Brief
Json
java学习的博客
09-22 115
1. 概念： JavaScript Object Notation JavaScript对象表示法 格式：var p = {"name":"张三","age":23,"gender":"男"}; * json现在多用于存储和交换文本信息的语法 * 进行数据的传输 * JSON 比 XML 更小、更快，更易解析。 2. 语法： 1. 基本规则 ...
轻量级的json操作类
aizhentang4540的博客
04-08 78
importjava.lang.reflect.Array;importjava.lang.reflect.Field;importjava.lang.reflect.ParameterizedType;importjava.lang.reflect.Type;importjava.util.Collection;importorg.json.JSONArray;impor...
json对象与字符串之间的转换
小白阿里里的博客
08-26 189
JSON对象与字符串的转换方法 // 使用 json 中的 parser 方法转换 var str = '{&quot;name&quot;: &quot;qwer&quot;, &quot;age&quot;: 22}'; // 这是一个JSON字符串 var obj = JSON.parse(str); // 返回一个新对象 console.log(obj); // 把 json 中的 strin..
java class 转 json 字符串工具
04-29
Java是一个广泛使用的面向对象编程语言，使用Java开发的应用程序通常需要与其他应用程序进行数据交换，而JSON是一种轻量级的数据交换格式。因此，将Java类转换为JSON字符串是一项非常重要的任务，以便在不同的应用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值