JSON 형식 문자열 해석 사고방식 및 기본 실현

0. 본 고 는 주로
자바 언어 를 사용 하여 JSON 형식 문자열 을 Map 이나 List 등 자바 데이터 구조 로 해석 합 니 다.
1. 설명
인터넷 에는 많은 예시 가 있 지만 어떤 것 은 어법 해석 과 문법 해석 을 동시에 실현 하고 어떤 것 은 많은 세부 적 인 부분 (오류 처리, 전의 문자 검사 등) 에 관심 을 가 졌 다. 진제 의 사고방식 이 뚜렷 하지 않다. 여기 서 사고방식 이 뚜렷 하지만 세부 적 인 실제 코드 와 사고방식 이 부족 하 다.
2, 해석 사고
JSON 형식 문자열 형식 에 오류 가 없다 고 가정 합 니 다. 먼저 문자열 을 분석 하여 키 문 자 를 가 져 옵 니 다. { } [ ] : , 그리고 각종 값 (문자열, 불 값, null, 수치) 을 재 귀적 인 방식 으로 세 가지 서로 다른 데 이 터 를 분석 합 니 다. JSONobject ({식별 을 통 해), JSONarray ([식별 을 통 해), 그리고 구체 적 인 값 입 니 다.
3, 구현 코드

package com.zhangbohun;

import java.io.*;
import java.util.*;

/**
 * @author zhangbohun
 * Create Date 2019/12/20 17:42
 * Modify Date 2019/12/20 17:42
 */
public class JSONParser
{

    private List scan(String str)
    {
        List l = new LinkedList();
        for(int i = 0; i < str.length(); i++)
        {
            switch(str.charAt(i))
            {
                case '{':
                case '}':
                case '[':
                case ']':
                case ',':
                case ':':
                    l.add(str.charAt(i));//    
                    break;
                case 'n':
                    l.add(null);
                    i += 3;
                    break;
                case 't':
                    l.add(true);
                    i += 3;
                    break;
                case 'f':
                    l.add(false);
                    i += 4;
                    break;
                case '"':
                    //     
                    StringBuilder sb = new StringBuilder();
                    for(int j = i + 1; j < str.length(); j++)
                    {
                        char ch = str.charAt(j);
                        if(ch == '\\')
                        {   //       
                            sb.append('\\');
                            sb.append(str.charAt(j += 1));
                        }
                        else if(ch == '"')
                        {     //      
                            l.add(sb.toString());
                            break;
                        }
                        else
                        {
                            sb.append(ch);
                        }
                    }
                    i += sb.length() + 1;
                    break;
                default:
                    //      
                    if(Objects.equals(str.charAt(i), ' ') || Objects.equals(str.charAt(i), '\t') || Objects.equals(str.charAt(i), '\r') || Objects.equals(str.charAt(i), '
'))
                    {
                        break;
                    }
                    //    （            ）
                    int j = i;
                    while(Character.isDigit(str.charAt(i)) || Objects.equals(str.charAt(i), '-') || Objects.equals(str.charAt(i), 'e') || Objects.equals(str.charAt(i), 'E') || Objects.equals(str.charAt(i), '+'))
                    {
                        i++;
                    }
                    l.add(Double.parseDouble(str.substring(j, i)));
                    i--;
                    break;
            }
        }
        return l;
    }


    private Object parse(List tokenList)
    {
        if(Objects.equals(tokenList.get(0), '{'))
        {
            tokenList.remove(0);//{
            Object value = parseObject(tokenList);
            tokenList.remove(0);//}
            return value;

        }
        else if(Objects.equals(tokenList.get(0), '['))
        {
            tokenList.remove(0);//[
            Object value = parseArray(tokenList);
            tokenList.remove(0);//]
            return value;
        }
        else
        {
            Object value = tokenList.get(0);
            tokenList.remove(0);
            return value;
        }
    }

    private Map parseObject(List tokenList)
    {
        Map m = new HashMap();
        while(!Objects.equals(tokenList.get(0), '}'))
        {
            Object key = tokenList.get(0);
            tokenList.remove(0);//key
            tokenList.remove(0);//:
            m.put(key, parse(tokenList));
            if(Objects.equals(tokenList.get(0), ','))
            {
                tokenList.remove(0);//,
            }
        }
        return m;
    }

    private List parseArray(List tokenList)
    {
        List l = new ArrayList();
        while(!Objects.equals(tokenList.get(0), ']'))
        {
            l.add(parse(tokenList));
            if(Objects.equals(tokenList.get(0), ','))
            {
                tokenList.remove(0);//,
            }
        }
        return l;
    }


    public Object parseFromString(String jsonString)
    {
        return parse(scan(jsonString));
    }

    public Object parseFromFile(File file) throws IOException
    {
        return parseFromStream(new FileInputStream(file));
    }

    public Object parseFromStream(InputStream inputStream) throws IOException
    {
        StringBuilder sb = new StringBuilder();

        InputStreamReader reader = new InputStreamReader(inputStream);
        BufferedReader br = new BufferedReader(reader);
        String s = br.readLine();
        while(s != null)
        {
            sb.append(s);
            s = br.readLine();
        }

        return parseFromString(sb.toString());
    }
}