原生JAVA解析json

最新推荐文章于 2024-05-16 09:25:50 发布
最新推荐文章于 2024-05-16 09:25:50 发布
阅读量4.8k 收藏 2
点赞数 1
分类专栏： 算法 文章标签： java 算法 json 原生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/icskee/article/details/77969963
版权

大概思路：
1.扫描出字符串
2.按顺序解析字符串

容易迷糊的地方
1.引用传递
2.解析逻辑

优点
1.能识别非标准json
2.一个类搞定
3.一次循环

缺点
1.非法string的值类型没做识别，懒得写了

package com.ics.sdk;

import java.math.BigInteger;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;

public class Json{
    private Json parent;
    private RegEx isInteger=new RegEx("^\\d+$");
    private RegEx isDouble=new RegEx("^\\d*\\.\\d+$");
    private RegEx isBoolean=new RegEx("^(true|false)$");
    private boolean isArray=false;
    private HashMap<String,Object> data=new HashMap<>();
    private List<Object> array=new ArrayList<>();

    public Json(){
        ChangeToItem();
    }

    public Json(ResultSet resultSet) throws Issue{
        ChangeToArray();
        try{
            ResultSetMetaData metaData=resultSet.getMetaData();
            int keysLength=metaData.getColumnCount();
            String[] keys=new String[keysLength];
            for(int i=0;i<keysLength;i++){
                keys[i]=metaData.getColumnLabel(i+1);
            }
            while(resultSet.next()){
                Json item=new Json();
                for(int i=0;i<keysLength;i++){
                    item.ItemSet(keys[i],resultSet.getString(keys[i]));
                }
                ArrayInsert(item);
            }
        }catch(SQLException e){
            //e.printStackTrace();
            throw new Issue("Json Init Issue",e);
        }
    }

    public Json(String content) throws Issue{
        int i=0;
        int l=content.length();
        StringBuffer v=new StringBuffer();
        boolean wordIsKey=false;
        Object wordTmp=null;
        int readType=0;//识别当前值存在位置  0等待    1数组value 2数组end   3key   4key end    5value  6value end
        char side=0;//当前值加载情况   0等待    1无引号   +引号
        Json p=this;
        Json j;
        String key=null;
        boolean isError=false;
        boolean isEnd=false;
        //扫描为字符串
        while(i<l){
            char w=content.charAt(i++);
            switch(w){
                case '[':
                case ']':
                case '{':
                case '}':
                case ':':
                case ',':
                    if(side==0){
                        wordTmp=w;
                        wordIsKey=true;
                    }else if(side==1){
                        wordTmp=v.toString();
                        v=new StringBuffer();
                        wordIsKey=false;
                        side=0;
                        i--;
                    }else{
                        v.append(w);
                    }
                    break;
                case '\'':
                case '"':
                    if(side==0){
                        side=w;
                    }else if(side==1){
                        wordTmp=v.toString();
                        v=new StringBuffer();
                        wordIsKey=false;
                        side=w;
                    }else{
                        if(side==w&&content.charAt(i-2)!='\\'){
                            wordTmp=v.toString();
                            v=new StringBuffer();
                            wordIsKey=false;
                            side=0;
                        }else{
                            v.append(w);
                        }
                    }
                    break;
                case ' ':
                    if(side==1){
                        wordTmp=v.toString();
                        v=new StringBuffer();
                        wordIsKey=false;
                        side=0;
                    }
                    if(side>1){
                        v.append(w);
                    }
                    break;
                default:
                    if(side==0){
                        side=1;
                    }
                    v.append(w);
            }
            if(wordTmp!=null){//解析字符串
                String word=wordTmp.toString();
                wordTmp=null;
                //Log.Info(word+"\n");
                switch(readType){
                    case 0:
                        if(wordIsKey){
                            if(word.equals("[")){
                                ChangeToArray();
                                readType=1;
                            }else if(word.equals("{")){
                                ChangeToItem();
                                readType=3;
                            }else{
                                isError=true;
                            }
                        }else{
                            isError=true;
                        }
                        break;
                    case 1:
                        if(wordIsKey){
                            if(word.equals("[")){
                                j=new Json();
                                j.ChangeToArray();
                                j.parent=p;
                                p.ArrayInsert(j);
                                p=j;
                                readType=1;
                            }else if(word.equals("{")){
                                j=new Json();
                                j.parent=p;
                                p.ArrayInsert(j);
                                p=j;
                                readType=3;
                            }else{
                                isError=true;
                            }
                        }else{
                            SetValue(p,word);
                            readType=2;
                        }
                        break;
                    case 2:
                        if(wordIsKey){
                            if(word.equals(",")){
                                readType=1;
                            }else if(word.equals("]")){
                                p=p.parent;
                                if(p==null){
                                    isEnd=true;
                                }else if(p.isArray){
                                    readType=2;
                                }else{
                                    readType=6;
                                }
                            }
                        }else{
                            isError=true;
                        }
                        break;
                    case 3:
                        if(wordIsKey){
                            isError=true;
                        }else{
                            key=word;
                            readType=4;
                        }
                        break;
                    case 4:
                        if(wordIsKey&&word.equals(":")){
                            readType=5;
                        }else{
                            isError=true;
                        }
                        break;
                    case 5:
                        if(wordIsKey){
                            if(word.equals("[")){
                                j=new Json();
                                j.ChangeToArray();
                                j.parent=p;
                                p.ItemSet(key,j);
                                p=j;
                                readType=1;
                            }else if(word.equals("{")){
                                j=new Json();
                                j.parent=p;
                                p.ItemSet(key,j);
                                p=j;
                                readType=3;
                            }else{
                                isError=true;
                            }
                        }else{
                            SetValue(p,key,word);
                            key=null;
                            readType=6;
                        }
                        break;
                    case 6:
                        if(wordIsKey){
                            if(word.equals(",")){
                                readType=3;
                            }else if(word.equals("}")){
                                p=p.parent;
                                if(p==null){
                                    isEnd=true;
                                }else if(p.isArray){
                                    readType=2;
                                }else{
                                    readType=6;
                                }
                            }else{
                                isError=true;
                            }
                        }else{
                            isError=true;
                        }
                        break;
                }
                if(isEnd&&i<l||isError){
                    throw new Issue("index["+i+"]word["+word+"]\n"+content);
                }
                //Log.Info(word+"\n");
                //Log.Info(isError+"\n");
            }
        }
        //Log.Info(this);
    }

    public static void main(String[] args){
        try{
            //new Json(" {a:1,b:'2\\'3',c:{d:5,f:'{}[]:,\\'\"'}}");
            //new Json("    [1,2,[4,5,6],[7,[8,[[9],10]]],[[[[11]]]]]");
            //new Json(" [{a:1},9,{c:3}]");
            new Json(" {a:1,b:[2,3],c:4]");//this is error
            //new Json(" [{a:1},2,{c:3},'d',{f:[5,6],h:{i:7,j:[{g:8}]}}]");
        }catch(Issue e){
            Log.Info(e);
        }
    }

    private Object GetValue(String value){
        if(isInteger.Test(value)){
            return new BigInteger(value);
        }else if(isDouble.Test(value)){
            return Double.parseDouble(value);
        }else if(isBoolean.Test(value)){
            return Boolean.parseBoolean(value);
        }else{
            return value;
        }
    }

    private void SetValue(Json json,String key,String value){
        json.ItemSet(key,GetValue(value));
    }

    private void SetValue(Json json,String value){
        json.ArrayInsert(GetValue(value));
    }

    public void ChangeToItem(){
        isArray=false;
    }

    public void ChangeToArray(){
        isArray=true;
    }

    /*******************item*******************/
    public boolean ItemExist(String key){
        return data.containsKey(key);
    }

    public void ItemSet(String key,Object value){
        data.put(key,value);
    }

    public Object ItemGet(String key){
        return data.get(key);
    }

    public void ItemDelete(String key){
        if(!isArray){
            data.remove(key);
        }
    }

    public String[] ItemKeys(){
        Set<String> keySet=data.keySet();
        String[] keys=new String[keySet.size()];
        keySet.toArray(keys);
        return keys;
    }

    /*******************array*******************/
    public int ArrayLength(){
        return array.size();
    }

    public int ArrayIndexOf(Object item){
        return array.indexOf(item);
    }

    public boolean ArrayExist(Object item){
        return ArrayIndexOf(item)>=0;
    }

    public Object ArrayGet(int index){
        return array.get(index);
    }

    public Json ArrayGetJson(int index){
        return (Json)ArrayGet(index);
    }

    public void ArrayInsert(Object item){
        array.add(item);
    }

    public void ArrayInsert(Object item,int index){
        array.add(index,item);
    }

    public void ArrayRemove(Object item){
        array.remove(item);
    }

    public void ArrayRemove(int index){
        array.remove(index);
    }

    /*******************table*******************/
    public Object TableGet(int row,String key){
        Json json=ArrayGetJson(row);
        if(json==null){
            return null;
        }else{
            return json.ItemGet(key);
        }
    }

    public String TableGetString(int row,String key){
        Object value=TableGet(row,key);
        if(value==null){
            return null;
        }else{
            return value.toString();
        }
    }

    public int TableGetInteger(int row,String key) throws Issue{
        Object value=TableGet(row,key);
        try{
            return Integer.parseInt(value.toString());
        }catch(Exception e){
            throw new Issue("row["+row+"]key["+key+"]value["+value+"]",e);
        }
    }

    public double TableGetDouble(int row,String key) throws Issue{
        Object value=TableGet(row,key);
        try{
            return Double.parseDouble(value.toString());
        }catch(Exception e){
            throw new Issue("row["+row+"]key["+key+"]value["+value+"]",e);
        }
    }

    public String toString(){
        String rs="";
        if(isArray){
            for(int i=0, l=array.size();i<l;i++){
                rs+=","+array.get(i);
            }
            if(rs.length()>0){
                rs=rs.substring(1);
            }
            return "["+rs+"]";
        }else{
            String[] keys=ItemKeys();
            for(int i=0, l=keys.length;i<l;i++){
                Object v=ItemGet(keys[i]);
                if(v instanceof String){
                    v="\""+((String)v).replaceAll("\\\\","\\\\\\\\").replaceAll("\"","\\\\\"")+"\"";
                }
                rs+=",\""+keys[i]+"\":"+v;
            }
            if(rs.length()>0){
                rs=rs.substring(1);
            }
            return "{"+rs+"}";
        }
    }
}
icskee
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 原生json解析_json原生解析
weixin_39991222的博客
02-16 546
packagecom.tfot.hotel.yichengyiyu.Activity.zhou_activity;importandroid.content.Intent;importandroid.os.Bundle;importandroid.support.annotation.Nullable;importandroid.view.View;importandroid.widget.Ada...
在 Java 中只用 JDK 自带的类库解析 JSON
Itmastergo的博客
02-22 1092
在 Java 中，解析 JSON（JavaScript Object Notation）是一项常见的任务，它允许我们在应用程序中处理和交换数据。虽然 Java 标准库中没有提供专门用于 JSON 解析的类，但是可以使用 JDK 自带的类库以及第三方库来完成这项任务。
Java JSON数组的解析
最新发布
qq_31532979的博客
05-16 999
本篇博客介绍了如何使用Java高效地解析JSON数组。我们使用了Jackson库作为示例，并给出了具体的Java代码。通过使用这些代码，我们可以轻松地将JSON数组解析为Java对象，并方便地访问其中的属性值。同时，我们还给出了一个案例分析，展示了如何在实际开发中应用上述代码。希望本篇博客对你学习和使用Java解析JSON数组有所帮助。Jackson官方文档Gson官方文档Fastjson官方文档。
java 原生json解析,Java fastjson解析json字符串实现过程解析
weixin_29871897的博客
03-20 434
jar的下载maven方式com.alibabafastjson1.2.67jar包百度云链接：https://pan.baidu.com/s/1x_C4ii3OFMXbsoqikmZKGw 提取码：ku6z示例解析json数组JSONObject jsonObject = JSON.parseObject(res.toString());JSONArray jsonArray = jsonObj...
java 原生解析json字符串,Android学习之JSON解析 (一) 原生技术解析JSON
weixin_39754616的博客
03-12 233
前言本人学生一枚，若文章中出现错误，请大佬指出。每篇格言：不管何时何地做你想做的事永远都不嫌晚，如果你发现生活不如意，我希望你有勇气重来一、 什么是JSON:借用百科的介绍:JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。它基于 ECMAScript (w3c制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据...
Java 原生 JSON 序列化
zhangxin09的专栏
01-29 3882
首先要说的是，笔者之前着实足够奇葩，净干别人未干过的事情，居然会想到用 JS 引擎来转换 JSON（《用 Rhino/Nashorn 代替第三方 JSON 转换库》、《使用 Rhino 作为 Java 的 JSON 解析/转换包》），几经思考后，还是决然毅然放弃这个不切实际的想法，老老实实去写转换函数，几经打磨，有了下面“序列化” JSON 的 toJSON() 函数。 原理分析 请先过目源码。 ...
Json源生解析
flying_fish_wj的博客
08-17 668
反解析生成Json格式 TestJson.java public class TestJson { public static void main(String[] args) { JSONObject object = new JSONObject(); object.put("firstName", "John"); object.p
java json原生解析.zip
11-26
总的来说，Java原生的JSON解析虽然不如第三方库功能全面，但对于简单的需求，它提供了一种简洁的解决方案。了解和掌握这部分知识，有助于理解JSON数据的处理流程，并能在没有引入额外依赖的情况下进行基本的JSON操作...
JAVA解析JSON数据代码需要的多个jar包
07-27
在Java编程环境中，解析JSON数据是一项常见的任务，特别是在与Web服务交互、API开发或处理来自服务器的数据时。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，因其易读性和易于编写，被广泛用于...
java解析Json的两种方式
08-06
以上就是Java解析JSON的两种常见方法：使用JSON库（如json-lib、Jackson或Gson）和Java内置API。选择哪种方式取决于项目需求，如性能、兼容性、易用性等。对于大型项目，推荐使用成熟的库，如Jackson，它提供了更...
原生Java操作mysql数据库过程解析
08-25
【原生Java操作MySQL数据库过程解析】 在Java编程中，直接使用Java标准API与MySQL数据库交互被称为原生操作。以下是一步一步详细讲解如何在Java项目中实现这一过程。 1. **引入数据库驱动** 首先，我们需要在项目...
Android开发之原生解析复杂的json数据代码
06-03
总之，Android原生解析JSON数据涉及到的关键知识点包括：JSON数据结构的理解、`JSONObject`和`JSONArray`的使用、遍历和解析嵌套结构、以及结合网络请求获取并处理JSON数据。在实际开发中，根据项目的具体需求，可以...
java解析JSON数据(原生json解析对象与数组)
qq_43670845的博客
08-13 3378
一. 导入解析json的工具类 import org.json.JSONException; import org.json.JSONObject; import org.json.JSONArray; 我们都知道JSON中有json对象与json数组（json数据就是json对象的数组） json对象在大括号中 例如：{“key”,”value”} json数组在中括号中 例如：[{“key”,...
原生Json数据的解析
ToastIt的博客
04-15 3477
前言： Json数据解析在获取接口数据是经常需要用到的，现在因为这一需求， 市面上也有不少jar可以帮助我们快速的解析Json数据， 比如：谷歌的Gson，阿里巴巴的Fastson，如果你已经有了非常不错的java基础了， 基本上这篇就不用看了，这里主要讲的主要是，把json数据解析成java对象， 把json数据解析成list集合，相对复杂的js
原生的JSON解析
Myair_AC的博客
08-29 465
1 . json官方提供：JSON 来看四种需要解析的不同类型: 首先是需要用到的Person类package com.qf.demo;public class Person { private String name; private int age; public Person() { // TODO Auto-generated constructor
纯java解析json,Java解析JSON
weixin_34190533的博客
03-13 157
《java世界观》文集说明本文集记载的所有内容均是java的学习笔记，主要重点记录概念，可能不会为每个概念列举完整的代码例子，更多代码例子请移步《java种田记》文集本文主要涉及内容来自开课吧新职课-JavaEE开发工程师V2.0若有错漏之处，欢迎各位指正JSONJSON(JavaScript Object Notation，JS对象简谱)，是一种轻量级的数据交换格式，主要用于网络数据传输。这里简...
【java】序列化与反序列化：原生和json
橙子的博客
06-11 1004
标记一个类的版本，如果我们不指定版本号，每当我们修改或添加一个类的字段或者方法，jdk就会自动根据属性和方法等参数生成一个id号。关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被。反序列化的时候的id号和序列化时候的id号不一致就会反序列化失败。变量因为不属于任何对象(Object)，所以无论有没有。被序列化的类实现Serializable接口。修饰的变量值不会被持久化和恢复。对于不想进行序列化的变量，使用。关键字修饰，均不会被序列化。如果有些字段不想进行序列化，
Java中的JSON解析
程序员小熊的博客
03-10 1693
Java与JSON 做什么? 将Java中的对象 快速的转换为 JSON格式的字符串. 将JSON格式的字符串, 转换为Java的对象. （一）Gson Gson（又称Google Gson）是Google公司发布的一个开放源代码的Java库，主要用途为将Java对象转换为JSON字符串，或将JSON字符串转换成Java对象。 Gson官网：Gson. Gson源码地址：Google/Gson 1.1 将对象转换为JSON字符串 转换JSON字符串的步骤: 引入Gson的jar包 在需要转换JSON字符串
Java解析JSON文件
热门推荐
Jeck_wu的博客
07-15 3万+
这篇文章主要讲讲 通过java去解析不同地方的json文件 通常我们需要解析本地的json文件或者服务器上的json文件。我们用来解析json格式的jar包有很多，jackson，fastjson，gson都行。但本人喜欢用fastjson。所以本篇都是以fastjson来解析json文件。 1.解析本地json文件 随便把一个json文件存储在本地的一个文件夹下，然后通过文件流将json文件内容读取出来。 然后转换成String，最后转json对象，然后再解析，获取自己想要的数据。 首先我们这个json文
原生java获取json中的value的值
03-26
可以使用Java中提供的JSON库，如Jackson、Gson等，通过解析JSON字符串获得JSON对象，再通过键值对的方式获取相应的值。 以Jackson为例： ```java String jsonStr = "{\"name\":\"张三\",\"age\":20}"; ObjectMapper mapper = new ObjectMapper(); JsonNode rootNode = mapper.readTree(jsonStr); String name = rootNode.get("name").asText(); int age = rootNode.get("age").asInt(); ``` 以上代码将JSON字符串解析成JsonNode对象，通过get方法获取对应的值，并将值转化为相应的类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值