手写的java实体类和json转化。

最新推荐文章于 2024-07-26 03:25:50 发布
最新推荐文章于 2024-07-26 03:25:50 发布
阅读量1.8k 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/faicm/article/details/48416895
版权

==

去年写的两个小类，代码很简单。

==

==

toJson

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Jsonhelp {
	public static void main(String[] args) {

		HashMap<Object, Object> map = new HashMap<Object, Object>();
		map.put("112", "12");
		map.put("1ui", 3);
		Y t = new Y();
		map.put("c", t);
		ArrayList<Y> list = new ArrayList<Y>();
		list.add(t);
		list.add(t);
		Y[] t1 = {new Y(), new Y()};
		map.put("list", list);
		map.put("arr", t1);
		System.out.println(toJson(map));

	}

	public static String toJson(Object o) {
		try {
			return toJsonMain(o);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	private static Object fromJson(String o, Class c) {

		// return new JsonParser(o,c).parse();
		return null;
	}

	private static String toJsonMain(Object o) {
		if (isBaseClass(o))
			return toJsonBase(o);
		if (isBase(o)) {
			if (o.getClass() == String.class)
				return "\"" + o + "\"";
			return o + "";
		}
		if (isArray(o)) {
			return toJsonArray(o);
		}
		if (isCollection(o)) {
			return toJsonCollection(o);
		}
		if (isMap(o)) {
			return toJsonMap(o);
		}
		return "";
	}

	private static String toJsonBase(Object o) {
		Class c = o.getClass();
		Field[] fs = c.getDeclaredFields();
		String result = "{";
		if (fs == null || fs.length == 0) {
			return "";
		}
		for (Field f : fs) {
			f.setAccessible(true);
			try {
				Object value = f.get(o);
				String key = f.getName();
				if (value == null) {
					value = "\"\"";
				} else if (isBase(value)) {
					value = "\"" + value + "\"";
				} else {
					value = toJsonMain(value);
				}

				result += "\"" + key + "\":" + value + ",";
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return result.substring(0, result.length() - 1) + "}";
	}

	private static String toJsonArray(Object o) {

		if (o.getClass() == int[].class) {
			return tointArrayJson(o);
		}
		if (o.getClass() == double[].class) {
			return todoubleArrayJson(o);
		}
		if (o.getClass() == long[].class) {
			return tolongArrayJson(o);
		}
		if (o.getClass() == char[].class) {
			return tocharArrayJson(o);
		}
		if (o.getClass() == byte[].class) {
			return tobyteArrayJson(o);
		}
		if (o.getClass() == boolean[].class) {
			return tobooleanArrayJson(o);
		}
		if (o.getClass() == float[].class) {
			return tofloatArrayJson(o);
		}
		if (o.getClass() == short[].class) {
			return toshortArrayJson(o);
		}
		Object[] arr = (Object[]) o;
		String result = "[";
		for (Object a : arr) {
			if (a == null) {
				result += ",";
				continue;
			}
			if (isBase(a)) {
				result += (a + ",");
				continue;
			} else {
				result += toJsonMain(a) + ",";
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String toJsonMap(Object o) {
		Map<Object, Object> map = (Map<Object, Object>) o;
		String result = "{";
		Set<Object> set = map.keySet();
		if (set.size() == 0)
			return "{}";
		Iterator<Object> iter = set.iterator();
		while (iter.hasNext()) {
			String str = iter.next() + "";
			result += ("\"" + str + "\"");
			Object obj = map.get(str);
			if (isBase(obj)) {
				if (obj.getClass() == String.class) {
					result += ":" + "\"" + obj + "\",";
				} else {
					result += ":" + obj + ",";
				}
			} else {
				result += (":" + toJsonMain(obj) + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "}";
	}

	private static String toJsonCollection(Object o) {
		Collection<Object> cs = (Collection) o;
		if (cs == null || cs.size() == 0) {
			return "\"\"";
		}
		String resule = "[";
		for (Object oc : cs) {
			resule += toJsonMain(oc) + ",";
		}
		return resule.substring(0, resule.length() - 1) + "]";
	}

	private static boolean isArray(Object o) {
		return o.getClass().toString().startsWith("class [");
	}

	private static boolean isMap(Object o) {
		return isMapDo(o.getClass());
	}

	private static boolean isBaseClass(Object o) {
		return !(isBase(o) || isArray(o) || isCollection(o) || isMap(o));
	}

	private static boolean isCollection(Object o) {
		return isCollectionDo(o.getClass());
	}

	private static boolean isMapDo(Class o) {
		Class[] interfaces = o.getInterfaces();
		for (Class i : interfaces) {
			if (i == Map.class)
				return true;
			if (i.getInterfaces() != null)
				return isMapDo(i);
		}
		return false;
	}

	private static boolean isCollectionDo(Class o) {
		Class[] interfaces = o.getInterfaces();
		for (Class i : interfaces) {
			if (i == Collection.class)
				return true;
			if (i.getInterfaces() != null)
				return isCollectionDo(i);
		}
		return false;
	}

	private static boolean isBase(Object o) {
		Class c = o.getClass();
		if (c == Integer.class || c == Byte.class || c == Boolean.class
				|| c == Double.class || c == Float.class || c == Long.class
				|| c == String.class || c == Short.class
				|| c == Character.class)
			return true;
		else
			return false;
	}

	private static String tointArrayJson(Object o) {
		int[] arr = (int[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String tolongArrayJson(Object o) {
		long[] arr = (long[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String todoubleArrayJson(Object o) {
		double[] arr = (double[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String tobooleanArrayJson(Object o) {
		boolean[] arr = (boolean[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String tocharArrayJson(Object o) {
		char[] arr = (char[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String tobyteArrayJson(Object o) {
		byte[] arr = (byte[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String tofloatArrayJson(Object o) {
		float[] arr = (float[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}

	private static String toshortArrayJson(Object o) {
		short[] arr = (short[]) o;
		String result = "[";
		for (Object a : arr) {
			if (isBase(a)) {
				result += (a + ",");
			}
		}
		return result.substring(0, result.length() - 1) + "]";
	}
}

// some Class for Test
class P {
	// int age = 12;
	// int name = 11;
	// int[] p = { 12, 4, 23 };
	// Z z = new Z();
	// Y y = new Y();
	// Y[] y2 = { y, y };
	// ArrayList<Y> c = new ArrayList<Y>();
	HashMap<String, Object> map = new HashMap<String, Object>();

	private void addList() {
		// c.add(new Y());
		map.put("123", "123");
		map.put("ccc", new Y());
	}
}

class Z {
	int z = 1;
	int zu = 12;
	Y y = new Y();
}

class Y {
	int hh = 90;
	int xx = 99;
}


==


fromJson，这个代码找到了递归点后就上班了，一直也没有完成。。(⊙﹏⊙)b。。。

==

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class JsonParser {
	public String mainStr;
	public Class c;
	int flag = 0;
	int flagtype = 0;
	public Object obj;

	public JsonParser(String o, Class c) {
		this.mainStr = o;
		this.c = c;
	}

	public static void main(String[] args) {
		// \"name\":888,
		String o = "{\"age\":123,\"nam1e\":{\"a2ge\":123}}";
		String json = "{\"root\":" + o + "}";
		System.out.println(json);
		JsonParser p = new JsonParser(json, H.class);
		// Map<String, Object> map = new HashMap<String, Object>();
		// p.mainparse(map, "root");
		Node objmap = (Node) p.parse();
		H h = (H) p.getObject((Map) objmap.value);
		System.out.println(h.age);
	}

	private Object getObject(Map objmap) {
		try {
			Class hclass = c;
			Object h = hclass.newInstance();
			Field[] fs = hclass.getDeclaredFields();
			for (Field f : fs) {
				String sva = (String) objmap.get(f.getName());
				if (sva == null) {
					continue;
				}

				if (f.getType() == int.class) {
					f.set(h, Integer.parseInt(sva));
				} else {
					f.set(h, sva);
				}

			}
			return h;
		} catch (Exception e) {
			e.printStackTrace();
			return objmap;
		}

	}

	int num1 = 0;// [的数量
	int num2 = 0;// {的数量
	char bc = ' ';//

	private Object parse() {
		// char c = mainStr.charAt(flag++);
		flag++;
		char c = getType();
		// c = getType();
		if (c == '{') {
			return parseObj();
		} else if (c == '[') {
			return parseArr();
		} else {
			return null;
		}

	}

	private List parseArr() {// 未实现功能
		// String key = getKey();
		// HashMap<Object, Object> mapp = new HashMap<Object, Object>();
		List list = new ArrayList<Map>();
		while (mainStr.charAt(flag++) == ',') {
			char c = getType();
			if (c == '{') {
				list.add(parseObj());
			} else if (c == '[') {
				list.add(parseArr());
			} else if (c == '"') {
				list.add(parseString());
			} else {

			}
		}
		// mapp.put(key, list);
		return list;

	}

	// root: {"arr":[{"hh":"90","xx":"99"},{"hh":"90","xx":"99"}],
	private Node parseObj() {// { }
		// flag++;
		String key = getKey();
		HashMap<Object, Object> mapp = new HashMap<Object, Object>();
		Node node = new Node();
		node.key = key;
		char c = getType();
		if (c == '{') {
			Node n = parseObj();
			mapp.put(n.key, n.value);
		} else if (c == '[') {
			// list.add(parseArr());
		} else if (c == '"') {
			// list.add(parseString());
			Node n = parseString();
			mapp.put(n.key, n.value);
		} else {
		}
		while (mainStr.charAt(flag++) == ',') {
			char d = getType();
			if (d == '{') {
				Node n = parseObj();
				mapp.put(n.key, n.value);
			} else if (d == '[') {
				// list.add(parseArr());
			} else if (d == '"') {
				Node n = parseString();
				mapp.put(n.key, n.value);
				// list.add(parseString());
			} else {
			}
		}
		flag++;
		node.value = mapp;
		return node;
	}

	private char getType() {
		while (mainStr.charAt(flagtype++) != ':') {
			// break;
		}
		char c = mainStr.charAt(flagtype++);
		if (c != '{' && c != '[' && c != '"') {
			c = '"';
		}
		return c;// mainStr.charAt(flagtype++);
	}

	private Node parseString() {
		// HashMap<Object, Object> m = new HashMap<Object, Object>();
		String key = getKey();
		String value = getValue();
		// m.put(key, value);
		Node n = new Node();
		n.key = key;
		n.value = value;
		return n;
	}

	private Object getObj() {
		try {
			Object obj = c.newInstance();
			Field[] fs = c.getDeclaredFields();
			for (Field f : fs) {
				f.setAccessible(true);
				Class cc = f.getType();
				if (cc == int.class) {
					// if (map.containsKey(f.getName()))
					// f.set(obj, Integer.parseInt("" + map.get(f.getName())));
				}
			}
			return obj;
		} catch (Exception e) {
			e.printStackTrace();
			// TODO: handle exception
		}

		return null;
	}

	private String getKey() {
		String s = "";
		for (;;) {
			char q = mainStr.charAt(flag - 1);
			char c = mainStr.charAt(flag++);
			if (c == '\"' && (q == '{' || q == '[' || q == ','))
				break;
		}

		for (;;) {
			char word = mainStr.charAt(flag++);
			if (word == '\"' || word == ',') {
				break;
			}
			s += word;
		}
		System.out.println("key是：   " + s);
		return s;
	}

	private String getValue() {
		String s = "";
		// 出问题
		while (mainStr.charAt(flag++) == ':') {
			if (mainStr.charAt(flag + 1) == '\"')
				flag++;
			break;
		}
		for (;;) {
			char word = mainStr.charAt(flag++);
			if (word == '\"' || word == ',' || word == '}') {
				flag--;
				break;
			}
			s += word;
		}
		System.out.println("value是： " + s);
		return s;
	}

	class Node {
		String key;
		Object value;
	}
}

class H {
	int age = 123;
	int name = 888;
}


==

王飞2023
关注
c语言json数据转换成字符串,C语言将字符串转json
weixin_39980711的博客
05-17 2098
示例代码：#include #include #include char *strrpc(char *str,char *oldstr,char *newstr){/*将一个字符串中的某些字符进行替换str 需要替换的字符串oldstr 旧的字符串newstr 新的字符串*/char bstr[strlen(str)];//转换缓冲区memset(bstr,0,sizeof(bstr));for(...
2019史上最全java面试题题库大全800题含答案
m0_74823021的博客
11-27 650
2019史上最全java面试题题库大全800题含答案。
将Json对象转化为Java实体类
01-10
将Json对象转化为Java实体类 请输入要创建的类名：(格式为：*.java) Student.java 请输入json对象： {id : 10, name : '小明', age : 18, score : 88.5, city : '北京', isgood : true} 创建java实体类成功！
java中实体类转json字符串
最新发布
weixin_42038871的博客
07-26 810
字符串相关学习资料：https://edu.51cto.com/video/3832.htmlhttps://edu.51cto.com/video/4055.htmlJava中实体类转JSON字符串的实现指南 作为一名刚入行的开发者，你可能会遇到需要将Java中的实体类转换成JSON字符串的场景。这个过程虽然听起来复...
对象 互换 java_（转）Java中JSON字符串与java对象的互换实例详解
weixin_34898216的博客
02-13 325
在开发过程中，经常需要和别的系统交换数据，数据交换的格式有XML、JSON等，JSON作为一个轻量级的数据格式比xml效率要高，XML需要很多的标签，这无疑占据了网络流量，JSON在这方面则做的很好，下面先看下JSON的格式，JSON可以有两种格式，一种是对象格式的，另一种是数组对象，{"name":"JSON","address":"北京市西城区","age":25}//JSON的对象格式的字符...
java实体类转Json
xiao_a_gang的博客
01-14 3567
package com.zsjz.utils.tools; import java.io.IOException; import java.io.StringWriter; import java.util.List; import javax.servlet.http.HttpServletRequest; import net.sf.json.JSONArray; import
JAVA_手写json解析器(jParser)
MUTONG的博客
06-14 1175
手写json解析器(jParser) package 手写json解析器; import java.util.List; import java.util.Map; import java.util.stream.Collectors; import java.util.stream.Stream; /** * <p>json数据处理类</p> * @author lius */ public class jsonHandler { /** * 处理字符串json.
【一键生成代码】从vue到java再到groovy
weixin_64314555的博客
01-21 3020
一、简介 我们在平时开发业务代码时，必然涉及到大量的拷贝工作，比如新创建的表，要实现增删改查，如果没有代码生成器，那么是很痛苦的。 好在mybatis就提供了逆向工程提高我们的编码效率，在后面的mybatis-plus对其进行了封装，更加简化了代码生成额流程。 那么想不想要一条可以在页面ui操作的代码生成器呢？比如说从数据库结构的groovy文件，到java代码，甚至到前端vue的基础增删改查界面？ 本文使用mybatis-plus-generator提供的能力，结合velocity模板引擎，实现
Java对象转换方案分析与mapstruct实践
uuuyy_的博客
11-27 522
一 前言 随着系统模块分层不断细化，在Java日常开发中不可避免地涉及到各种对象的转换，如：DO、DTO、VO等等，编写映射转换代码是一个繁琐重复且还易错的工作，一个好的工具辅助，减轻了工作量、提升开发工作效率的同时还能减少bug的发生。 二 常用方案及分析 1 fastjson CarDTO entity = JSON.parseObject(JSON.toJSONString(carDO), CarDTO.class); 这种方案因为通过生成中间json格式字符串，然后再转化成目标对象，性能
Java面试题汇总（一）
m0_67322837的博客
03-14 775
本文分为十九个模块，分别是：Java 基础、容器、多线程、反射、对象拷贝、Java Web 、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM，如下图所示： 共包含 208 道面试题，本文的宗旨是为读者朋友们整理一份详实而又权威的面试清单，下面一起进入主题吧。 Java 基础 1. JDK 和 JRE 有什么区...
java中实体类和JSON对象之间相互转化
10-24
Java中关于Json格式转化Object,Map,Collection类型和String类型之间的转化在我们实际项目中应用的很是普遍和广泛。最近工作的过程中也是经常有，因此,自己封装了一个类分享给大家。
json格式与java类对象相互转换
10-12
json格式与java类对象相互转换。json格式转换成java类对象，List，Map。类对象转换成json。
JAVA-JSON工具转换类
06-19
该工具类包括多重的json字符串或Map或List的相互转换，该文件包括主要的jar包，可以快捷的使用工具
Java高级：java实体类转json字符串
m0_57286743的博客
07-09 274
数据库 2.1 池化技术：如何减少频繁创建数据库连接的性能损耗？ 2.2 数据库优化方案（一）：查询请求增加时，如何做主从分离？ 2.3 数据库优化方案（二）：写入数据量增加时，如何实现分库分表？ 2.4 发号器：如何保证分库分表后ID的全局唯一性？ 2.5 NoSQL：在高并发场景下，数据库和NoSQL如何做到互补？ 缓存 3.1 缓存：数据库成为瓶颈后，动态数据的查询要如何加速？ 3.2 缓存的使用姿势（一）：如何选择缓存的读写策略？ 3.3 缓存的使用姿势（二）：缓存如何做到高可用？ 3.4
java类转换json
GrowingSir
10-10 8787
package com.didi.haitangwan.sc.meta.dal; import com.alibaba.fastjson.JSONObject; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; public class Test { private Stri...
java将实体转换为json
weixin_41518742的博客
07-02 1014
Java实体转换为JSON教程 1. 整体流程 首先我们需要了解将Java实体转换为JSON的整体流程，可以用下面的表格展示： 步骤 描述 1 创建Java实体类 2 实例化实体对象 3 使用第三方库将实体对象转换为JSON字符串 2. 具体步骤及代码示例 步骤1：创建Java实体类 首先，我们...
Java实体和JSON之间的相互转换
热门推荐
studio_1的博客
05-05 1万+
writeValueAsString方法会保留没有显示初始化的的字段，除了char类型初始化值为“\u0000”，其他都为“null”。可以看到，直接使用toJSONString将Java实体转化为Json，会把没有显示初始化的字段丢掉。JSONObject是JSON的子类，并且没有重写“toJSONString”方法，所以效果是一样的。可以看到没有显示初始化的字段都保留下来了，并且值都为“null”。“\u0000”是char类型的默认值，相对于null。可以看到时间已经转换为目标格式。
学习笔记 利用反射 手写一个简单的实体类 转json 的方法
Lengff
12-04 397
不得不说 反射真的是个好动  # 贴上我的代码   package com.lengff.test; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class toJsonUtil {...
Java类与Json互相转换
Deslord的博客
10-15 616
Java 类与Json字符串 互相转换
JSP手写功能实体类代码实现
在JSP（JavaServer Pages）环境中，这样的实体类经常被用作后台处理数据的模型，配合控制器（Controller）和视图（View）来实现MVC（Model-View-Controller）设计模式。JSP页面可以使用这些实体类来展示或接收用户...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值