之前在做專案中，Json 這種資料轉換格式經常用，為什麼呢？我認為是
1、它的易用性，跨平臺性，它是JS(JavaScript)的子集，是一種物件字面量。
2、它與XML都是樹結構的語法樹；
同樣的XML,JSON表示，Json則相對簡潔，XML相對冗餘，當然也是互相不可替代的，根據具體需求選擇合適才是完美的。

做個原生的Json解析器是掌閱科技的大佬提出的一個問題，在之前沒有相對的深入瞭解這個Json解析器，專案裡用到的都是org.Json開源包\Gson包。這周就主要對Json解析器包括與塌相關的知識做個梳理，形成網路結構。想做Json解析器，必須對Json本身有了解，在這裡主要點出幾個下面需要用的點：
JSON結構：

"string"：Java的String；
number：Java的Long或Double；
true/false：Java的Boolean；
null：Java的null；
[array]：Java的List<Object>或Object[]；
{"key":"value"}：Java的Map<String, Object>。

JSON文法：

Jsonobject = {} | { members }
members = pair | pair , members
pair = string : value
array = [] | [ elements ]
elements = value | value , elements
value = string | number | object | array | true | false | null
string = “” | ” chars ”
chars = char | char chars
char = any-Unicode-character-except-“-or–or- control-character | \” | \ | \/ | \b | \f | \n | \r | \t | \u four-hex-digits
number = int | int frac | int exp | int frac exp
int = digit | digit1-9 digits | - digit | - digit1-9 digits
frac = . digits
exp = e digits
digits = digit | digit digits
e = e | e+ | e- | E | E+ | E-
細節可以參看《Json必知必會》

同時也要了解編譯原理的一些知識：
編譯過程：詞法分析，語法分析，語義分析，當然其中還有程式碼優化，目的碼；
其中，
詞法分析作用：找出單詞 。如int a=b+c; 結果為： int，a，=，b,+,c和;
語法分析作用：找出表示式，程式段，語句等。如int a=b=c;的語法分析結果為int a=b+c這條語句。
語義分析作用：檢視型別是否匹配等。

同時要了解解析器的功能，原理；
Json解析器是把輸入字串重新變成熟悉型別的物件，像一個函式，它的輸入是一個表示JSON的字串，輸出是結構化的對應到語言本身的資料結構。

在解析過程中，主要有兩部分一個是，詞法分析，將原始碼解析為詞法單元token；另一個是語法分析，構造語法樹parser；當然都是基於Json 詞法和文法。

在第一部分，形成詞法分析時，即是構造自動機（DFA）；在寫Json之前，我先手寫了幾個簡單的自動機，很久沒寫過，熱了下身，其實只要邏輯分析沒問題，是很簡單的，就是程式碼實現。
（a|bb)一個可以有’a’和’b’的字串，’b’出現時必為偶數個；

public class ABB {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception {
        // TODO code application logic here
        Scanner in =new Scanner(System.in);
        String string=in.nextLine();
        char[] ch=string.toCharArray();
        if(ch.length==0){
            throw new Exception("不合法字元!");
        }
        int i=0;
        while(i<ch.length){
            if(ch[i]=='a'){
                ++i;
            }else if(i<ch.length-1&&ch[i]=='b'){
                ++i;
                if(i<ch.length&&ch[i]=='b'){
                   ++i;
                }else{
                    throw new Exception("不合法字元！");
                }
            }else{
                throw new Exception("不合法字元！");
            }
        }
        System.out.println("合法字元！");
    }
}

由於Json 的結構特殊，在輸入第一字元的時候就可以判斷是哪個物件，{}/[]/string/true/false/number/null；我們可以加工構造並對應列舉型別即token流，進行詞法分析：

STRING（字串字面量）
NUMBER（數字字面量）
NULL（null）
START_ARRAY（[）
END_ARRAY（]）
START_OBJ（{）
END_OBJ（}）
COMMA（,）
COLON（:）
BOOLEAN（true或者false）
END_DOC（表示JSON資料的結束）

列舉型別：

public enum TokenType {
    START_OBJ, END_OBJ, START_ARRAY, END_ARRAY, NULL, NUMBER, STRING, BOOLEAN, COLON, COMMA, END_DOC
}

同時構造token類：

public class Token {
    private TokenType type;
    private String value;

    public Token(TokenType type, String value) {
        this.type = type;
        this.value = value;
    }

    public TokenType getType() {
        return type;
    }

    public void setType(TokenType type) {
        this.type = type;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String toString() {
        return getValue();
    }
}

在進行Json解析的詞法分析時，首先需要將字串轉為字元陣列，我們可以用BufferReader(new StringReader(String str));
關於BufferReader()可以見：https://www.cnblogs.com/meilidelaohuhua/p/6638545.html ;
轉化之後進行字元逐一分析，此時用到的是Json的結構的自動機，將其轉化為token流。此時第一部分詞法分析完成。
在第二部分語法樹parser構造中，主要分兩部分；
一塊是物件Object文法，一塊是陣列Array文法，其他文法是基本型別；
其中物件可以用Map實現（Key:Value)，陣列用List集合

public class JObject implements Json {
    private Map<String, Value> map = new HashMap<>();
    public JObject(Map<String, Value> map) {
        this.map = map;
    }

    public int getInt(String key) {
        return Integer.parseInt((String) map.get(key).value());
    }

    public String getString(String key) {
        return (String) map.get(key).value();
    }

    public boolean getBoolean(String key) {
        return Boolean.parseBoolean((String) map.get(key).value());
    }

    public JArray getJArray(String key) {
        return (JArray) map.get(key).value();
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{ ");
        int size = map.size();
        for (String key : map.keySet()) {
            sb.append(key + " : " + map.get(key));
            if (--size != 0) {
                sb.append(", ");
            }
        }
        sb.append(" }");
        return sb.toString();
    }
}
public class JArray implements  Json, Value {
    private List<Json> list = new ArrayList<>();

    public JArray(List<Json> list) {
        this.list = list;
    }

    public int length() {
        return list.size();
    }

    public void add(Json element) {
        list.add(element);
    }

    public Json get(int i) {
        return list.get(i);
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[ ");
        for (int i =0; i < list.size(); i++) {
            sb.append(list.get(i).toString());
            if (i != list.size() - 1) {
                sb.append(", ");
            }
        }
        sb.append(" ]");
        return sb.toString();
    }

    @Override
    public Object value() {
        return this;
    }
}

其中重要的是Json，和Value抽象類的建立得以使JObject和JArray相互轉化，動態的完成物件和陣列相互巢狀的轉化。
另外，在構造token 類的時候把列舉型別和Value為屬性，在後面新增list的時候，省了許多麻煩。
原始碼：https://github.com/weiyanyanyan/Json