yimengqiannian
yimengqiannian

自己写的java版的JSON解析器详解

自己写的java版的json解析器详解

前言

上回书说道，我用flex&bison写了个json解析的原理性示例，结果我那坑爹同事连看都不看一眼，我感到很桑心……

为了让这个同事能服我，我一定要写个java版的json解析……到时候一定让这个同事给我发一个大写的“服”字给我……

那同事还说，能写java版的json解析就可以去阿里工作了……我至今都觉得这是讽刺阿里没人才的高端黑……

因为，你看完了这篇文章，估计你也就能写个java版的json解析了……到时候咱一起去把阿里的门槛踏破呵~

另外，好多人不注意看文档结构……我发博客，后面肯定是会附上完整下载链接的……不想看文可以直接拖到后面下下来玩~

这次的程序有点长，我可能就不会粘贴所有代码了，提前告诉大家可以先下载后看文~

总体介绍

首先，这仍然是一个以探究原理为主的实现，结构清晰是第一，然后兼顾效率，我并不是想写一个比已有解析器厉害的东西……

当然，我自认为暂时还是没能力写出比已有的json第三方解析包厉害的东西……

项目的名字已经很明确了，multTravJsonParse——基于多次遍历的JSON解析……

其次，说一下，整个JSON解析使用的是遍历分析（词法解析）、状态机（语法解析）和堆栈（状态控制和操作），并非采用递归方式来实现的多次遍历解析……在语法分析时，是采用堆栈构造的……这跟递归是等效的，但是却可以免受JVM调用堆栈溢出问题的困扰……

先说一说文件结构吧，huaying1988神马鬼？不要在意这些细节，那是我因为身份证过期至今没备案成功的域名……

G:.
└─com
    └─huaying1988
        ├─multTravJsonParse
        │  │  JSON.java
        │  │
        │  ├─lex
        │  │      JsonLex.java
        │  │      TOK.java
        │  │      Token.java
        │  │      UnexpectedException.java
        │  │
        │  └─syntax
        │          Operator.java
        │          OPT.java
        │          STATE.java
        │          StateMachine.java
        │
        └─test
                TestJsonLex.java
                TestJSONParse.java
结构很明显，分为四部分：

  1. JSON.java——这是整个解析器的入口类，里面就一个静态方法parse，内容也很简单，就是创建StateMachine对象并调用parse方法，这个类大家都能看懂，不会再下面再详细讲了……
  2. lex包——这个很明显，是词法解析的包，里面定义了一个异常类，一个包含Token类型常量的TOK类，一个用来存储解析结果单元的Token类，还有一个词法解析器JsonLex类
  3. syntax包——也很明显，这个是语法解析的包，里面包含了一个包含状态常量定义的STATE类，一个状态机StateMachine类，一个包含操作常量OPT类，以及一个用来操作的Operator类
  4. test包——很明显，用来测试的，包含一个测试语法解析的TestJsonLex类，一个测试JSON解析的TestJSONParse类，这个类为了测试对比，引入了第三方的JSON解析包，那就是阿里某大牛的fastJSON包~
好了，总体的结构就是这样子，下面来一个一个的分析~

词法解析器

lex包里一共就四个文件，自定义的这个异常类我就不说了，主要是用来报错的时候好定位的……因为lex是整个json解析中离代码最近的一个处理，所以，所有的异常最后还是要在词法分析处生成比较好，因为它比较容易记录当前的行号和列号以及总字符数，报错的时候也容易告诉用户这些信息，所以JsonLex中有generateUnexpectedException方法，行号和列开头的堆栈，还有在nextChar和revertChar里面有关于行号的列号相关的处理操作……于是关于这个异常类，我就不贴代码了，目的很明确，大家估计也看得懂……

首先，要从TOK这个类开始，这里面记载类总共有多少个Token类型，当然，这个Token类型时从上一篇博客中json.l中直接扒过来的……

TOK.java代码

package com.huaying1988.multTravJsonParse.lex;

/**
 * 保存Token类型信息以及相关静态变量
 * 
 * @author huaying1988.com
 * 
 */
public class TOK {
	public static final int STR = 0;
	public static final int NUM = 1;
	public static final int DESC = 2;
	public static final int SPLIT = 3;
	public static final int ARRS = 4;
	public static final int OBJS = 5;
	public static final int ARRE = 6;
	public static final int OBJE = 7;
	public static final int FALSE = 8;
	public static final int TRUE = 9;
	public static final int NIL = 10;
	public static final int BGN = 11;
	public static final int EOF = 12;
	/**
	 * 并非tok类型，存储tok类型的个数，添加类型时请同步修改
	 */
	public static final int TOK_NUM = 13;
	/**
	 * 将tok类型转换为字符串的转换数组，添加类型时请同步修改
	 */
	public static final String[] CAST_STRS = { "STR", "NUM", "DESC", "SPLIT",
			"ARRS", "OBJS", "ARRE", "OBJE", "FALSE", "TRUE", "NIL", "BGN", "EOF" };
	
	/**
	 * 将tok类型转换为字符串的转换数组，添加类型时请同步修改
	 */
	public static final String[] CAST_LOCAL_STRS = { "字符串", "数字", ":", ",",
			"[", "{", "]", "}", "false", "true", "null", "开始", "结束" };

	/**
	 * 将tok类型转换为String,测试用显示结果的
	 * 
	 * @return
	 */
	public static String castTokType2Str(int type) {
		if (type < 0 || type > TOK_NUM)
			return "undefine";
		else
			return CAST_STRS[type];
	}
	
	/**
	 * 将tok类型转换为String,用于报错信息
	 * 
	 * @return
	 */
	public static String castTokType2LocalStr(int type) {
		if (type < 0 || type > TOK_NUM)
			return "undefine";
		else
			return CAST_LOCAL_STRS[type];
	}
}

里面保存了13个token类型，同时还包括对类型转换为字符串的方法……

之后便是重头戏，JsonLex.java，刚才说了它要记录行列字符进行字符串遍历（nextChar）、遍历控制（reverseChar），当然，词法解析才是这个类的重点。

package com.huaying1988.multTravJsonParse.lex;

import java.util.Stack;


/**
 * Json词法分析器
 * 
 * @author huaying1988.com
 * 
 */
public class JsonLex {
	// 当前行号
	private int lineNum = 0;
	// 用于记录每一行的起始位置
	private Stack colMarks = new Stack();
	// 用于报错的行游标
	private int startLine = 0;
	// 用于报错的列游标
	private int startCol = 0;
	// 当前字符游标
	private int cur = -1;
	// 保存当前要解析的字符串
	private String str = null;
	// 保存当前要解析的字符串的长度
	private int len = 0;

	/**
	 * JsonLex构造函数
	 * 
	 * @param str
	 *            要解析的字符串
	 */
	public JsonLex(String str) {
		if (str == null)
			throw new NullPointerException("词法解析构造函数不能传递null");
		this.str = str;
		this.len = str.length();
		this.startLine = 0;
		this.startCol = 0;
		this.cur = -1;
		this.lineNum = 0;
		this.colMarks.push(0);
	}

	public char getCurChar(){
		if (cur >= len - 1) {
			return 0;
		}else{
			return str.charAt(cur);
		}
	}
	public Token parseSymbol(char c) {
		switch (c) {
		case '[':
			return Token.ARRS;
		case ']':
			return Token.ARRE;
		case '{':
			return Token.OBJS;
		case '}':
			return Token.OBJE;
		case ',':
			return Token.SPLIT;
		case ':':
			return Token.DESC;
		}
		return null;
	}

	public boolean isLetterUnderline(char c) {
		return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_');
	}

	public boolean isNumLetterUnderline(char c) {
		return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
				|| (c >= '0' && c <= '9') || c == '_');
	}

	public boolean isNum(char c) {
		return (c >= '0' && c <= '9');
	}

	public boolean isDecimal(char c) {
		return ((c >= '0' && c <= '9') || (c == '.'));
	}

	private void checkEnd() {
		if (cur >= len - 1) {
			throw generateUnexpectedException("未预期的结束，字符串未结束");
		}
	}

	public UnexpectedException generateUnexpectedException(String str) {
		return new UnexpectedException(cur,startLine, startCol, str);
	}

	public UnexpectedException generateUnexpectedException(String str,
			Throwable e) {
		return new UnexpectedException(cur,startLine, startCol, str, e);
	}

	private String getStrValue(char s) {
		int start = cur;
		char c;
		while ((c = nextChar()) != 0) {
			if (c == '\\') {// 跳过斜杠以及后面的字符
				c = nextChar();
			} else if (s == c) {
				return str.substring(start + 1, cur);
			}
		}
		checkEnd();
		return null;
	}

	private String getNumValue() {
		int start = cur;
		char c;
		while ((c = nextChar()) != 0) {
			if (!isDecimal(c)) {
				return str.substring(start, revertChar());
			}
		}
		checkEnd();
		return null;
	}

	private Token getDefToken() {
		int start = cur;
		char c;
		while ((c = nextChar()) != 0) {
			if (!isNumLetterUnderline(c)) {
				String value = str.substring(start, revertChar());
				if ("true".equals(value)) {
					return Token.TRUE;
				} else if ("false".equals(value)) {
					return Token.FALSE;
				} else if ("null".equals(value)) {
					return Token.NIL;
				} else {
					return new Token(TOK.STR, value);
				}
			}
		}
		checkEnd();
		return null;
	}

	/**
	 * 获取下一个字节，同时进行 行、列 计数
	 * 
	 * @return 下一个字节，结束时返回0
	 */
	private char nextChar() {
		if (cur >= len-1) {
			return 0;
		}
		++cur;
		char c = str.charAt(cur);
		if (c == '\n') {
			++lineNum;
			colMarks.push(cur);
		}
		return c;
	}
	/**
	 * 撤回一个字节，同时进行 行、列 计数，返回撤回前的字符游标
	 * 
	 * @return 下一个字节，结束时返回0
	 */
	private int revertChar() {
		if (cur <= 0) {
			return 0;
		}
		int rcur = cur--;
		char c = str.charAt(rcur);
		if (c == '\n') {
			--lineNum;
			colMarks.pop();
		}
		return rcur;
	}

	public static boolean isSpace(char c) {
		return (c == ' ' || c == '\t' || c == '\n');
	}

	// str \"(\\\"|[^\"])*\"
	// def [_a-zA-Z][_a-zA-Z0-9]*
	// num -?[0-9]+(\.[0-9]+)?
	// space [ \t\n]+
	/**
	 * 获取下一个Token的主函数
	 */
	public Token next() {
		if (lineNum == 0) {
			lineNum = 1;
			return Token.BGN;
		}
		char c;
		while ((c = nextChar()) != 0) {
			startLine = lineNum;
			startCol = getColNum();
			if (c == '"' || c == '\'') {
				return new Token(TOK.STR, getStrValue(c));
			} else if (isLetterUnderline(c)) {
				return getDefToken();
			} else if (isNum(c) || c=='-') {
				return new Token(TOK.NUM, getNumValue());
			} else if (isSpace(c)) {
				continue;
			} else {
				return parseSymbol(c);
			}
		}
		if (c == 0) {
			return Token.EOF;
		}
		return null;
	}

	public int getLineNum() {
		return lineNum;
	}

	public int getColNum() {
		return cur - colMarks.peek();
	}

	public int getCur() {
		return cur;
	}

	public String getStr() {
		return str;
	}

	public int getLen() {
		return len;
	}
}
构造函数初始化就不说了……一些简单的Get/Set、字符判断也不说了……词法解析的主函数入口是这个类中的next，负责返回下一个Token……

同事问我Token是啥……Token就是一个实体对象类，里面主要存了两个属性，类型和值……词法解析的主要作用是预处理，将复杂的字符串转换为相对简单而统一的类型，而这个统一类型，我们把它称之为Token，而词法解析就是讲字符流转换为Token流的一个过程……我想，这么说同事应该能听懂……

当然，大部分的Token只需要类型就行了，只有少数复杂的Token类型有值，那就是STR（字符串）、NUM（数字）这两种类型的Token……

Next这个方法循环调用nextChar获取下一个字符，碰见某种类型的初始字符，就开始进入相应Token类型的处理函数中，最终返回Token类型的对象……

其中parseSymbol，字符类型的Token没什么好说的……最麻烦的就是STR（字符串）、NUM（数字）这两种类型，它们除了有类型还有值，处理函数分别是getStrValue和getNumValue……行数都不多，大约看看也能懂……空格字符略过，没什么好说的……除此之外，还有一个getDefToken，这个一方面是用来处理true、false、null的，看过上篇文章中json.l文件的大约能懂这个是啥……另一方面是针对不严格JSON中的key的……因为我经常写不严格的JSON，所以，这个要能处理，可以看到，这种情况作为STR（字符串）类型处理了……

最后看看Token这个实体类：

package com.huaying1988.multTravJsonParse.lex;

/**
 * 保存token
 * 
 * @author huaying1988.com
 * 
 */
public class Token {
	public static final Token DESC = new Token(TOK.DESC);
	public static final Token SPLIT = new Token(TOK.SPLIT);
	public static final Token ARRS = new Token(TOK.ARRS);
	public static final Token OBJS = new Token(TOK.OBJS);
	public static final Token ARRE = new Token(TOK.ARRE);
	public static final Token OBJE = new Token(TOK.OBJE);
	public static final Token FALSE = new Token(TOK.FALSE);
	public static final Token TRUE = new Token(TOK.TRUE);
	public static final Token NIL = new Token(TOK.NIL);
	public static final Token BGN = new Token(TOK.BGN);
	public static final Token EOF = new Token(TOK.EOF);

	// 从TOK类中定义的类型
	private Integer type;
	// 该tok的值
	private String value;

	public Token(int type) {
		this.type = type;
		this.value = null;
	}

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

	public int getType() {
		return type;
	}

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

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}
	
	public static String unescape(String str) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < str.length(); i++) {
			char c = str.charAt(i);
			if (c == '\\') {
				c = str.charAt(++i);
				switch (c) {
					case '"':
						sb.append('"');
						break;
					case '\\':
						sb.append('\\');
						break;
					case '/':
						sb.append('/');
						break;
					case 'b':
						sb.append('\b');
						break;
					case 'f':
						sb.append('\f');
						break;
					case 'n':
						sb.append('\n');
						break;
					case 'r':
						sb.append('\r');
						break;
					case 't':
						sb.append('\t');
						break;
					case 'u':
						String hex = str.substring(i+1, i+5);
						sb.append((char)Integer.parseInt(hex, 16));
						i+=4;
						break;
					default:
						throw new RuntimeException("“\\”后面期待“\"\\/bfnrtu”中的字符，结果得到“"+c+"”");
				}
			}else{
				sb.append(c);
			}
		}
		return sb.toString();
	}
	
	public Object getRealValue(){
		Object curValue = null;
		switch(this.getType()){
		case TOK.TRUE:
			curValue = true;
			break;
		case TOK.FALSE:
			curValue = false;
			break;
		case TOK.NIL:
			curValue = null;
			break;
		case TOK.NUM:
			if(value.indexOf('.')>=0){
				curValue = Double.parseDouble(value);
			}else{
				curValue = Integer.parseInt(value);
			}
			break;
		case TOK.STR:
			curValue = unescape(value);
			break;
		}
		return curValue;
	}

	public String toString() {
		if (this.type > 1) {
			return "[" + TOK.castTokType2Str(this.type) + "]";
		} else {
			return "[" + TOK.castTokType2Str(this.type) + ":" + this.value
					+ "]";
		}
	}
	
	public String toLocalString() {
		if (this.type > 1) {
			return "“" + TOK.castTokType2LocalStr(this.type) + "”";
		} else {
			return "“" + TOK.castTokType2LocalStr(this.type) + ":" + this.value
					+ "”";
		}
	}
}

这个实体类把所有没有值得Token都定义了静态常量，这个无非就是刚才说的兼顾效率，每次都new没什么意思，当然第二点是为了对比判断方便……

对于不含值的Token类型可以直接用==判断，因为两个指向的是同一个对象，所以能直接进行指针判断，也是挺爽的不是……尤其是对于EOF（文件结束）类型的Token，判断循环结束条件尤其好用……

除了这些静态常量，还有刚才说的类型、值两个属性，get/set方法，还有toString方法之外，不得不提的是getRealValue和unescape这两个方法……

有值的就那么几个……NUM类型还判断了一下是int类型还是double类型……这些都不难理解……unescape方法是将字符串中的转义字符化解掉……变成真正实际的字符串……

而这个unscape方法就是传说中的对字符串的第二次遍历……对应项目名多次遍历，这就是其中一个点……如果设计巧妙点可以一次性的解决STR（字符串）、NUM（数字）类型的值得问题，但是，就当前项目来说，写到这份上，也是可以了……也不枉担一个多次遍历的名分……

这样，整个词法分析器就讲完了……貌似没什么太难以理解的地方……跟上篇文章一样，词法解析一般都不成难点，等你从词法分析入坑之后才发现：麻烦才刚刚开始……

语法解析器

接下来的事情变得高级起来了……高级得有时候一下子就不懂了……更确切的说是——太抽象了……

编译原理难学就在于它太抽象了……用到了很多极端抽象的东西……比如说，下面要说的状态自动机就是这么个东西……

上篇文章已经说了，这个JSON解析器的总体实现都是一晚上搞出来的东西……这一晚上在语法解析器这儿，我曾经设想过好多的方案……

比如说采用yacc/bison那样语法树的输入形式，然后进行一个树状遍历……但是我终究没这么干……因为我毕竟不想写一个像yacc/bison那样的通用解析器……

于是我选择了状态自动机……说起状态自动机来，这是编译原理里面比较晦涩的一个东西……但是当我把JSON演变的状态自动机画出来，也不过如此了……

画的不好看，很乱，其中还可能有错误，但是不想改了，维持原样吧……这个图是第二天给那个同事讲解的时候画的，然而因为那天晚上熬到很晚，所以第二天画这个图的时候精神状态自然也不怎么样，大家凑合着看吧：

自己写的java版的JSON解析器详解_第1张图片

同事问，你在实现这个的时候，是先画了这么张图么？当然——没有……我要是画了这么张图，也不至于花了一晚上去实现啊……

这是先实现的，后有了这张图啊……看不懂？没关系，接着再往下看，慢慢就懂了……

先看一下状态定义类STATE.java：

package com.huaying1988.multTravJsonParse.syntax;

import java.lang.reflect.Method;

import com.huaying1988.multTravJsonParse.lex.TOK;

/**
 * 保存状态列表、状态转换矩阵等静态常量
 * @author huaying1988.com
 *
 */
public class STATE {
	//开始态
	public static final Integer BGN = 0;
	//数组值前态
	public static final Integer ARRBV = 1;
	//数组值后态
	public static final Integer ARRAV = 2;
	//对象键前态
	public static final Integer OBJBK = 3;
	//对象键后态
	public static final Integer OBJAK = 4;
	//对象值前态
	public static final Integer OBJBV = 5;
	//对象值后态
	public static final Integer OBJAV = 6;
	//结果态
	public static final Integer VAL = 7;
	//结束态
	public static final Integer EOF = 8;
	//错误态
	public static final Integer ERR = 9;
	
	//状态机的状态转换矩阵
	public static final Integer[][] STM = {
			/*INPUT——STR NUM DESC SPLIT ARRS OBJS ARRE OBJE FALSE TRUE NIL BGN*/
			/*BGN*/  {VAL,VAL,ERR,ERR,ARRBV,OBJBK,ERR,ERR,VAL,VAL,VAL,BGN},
			/*ARRBV*/{ARRAV,ARRAV,ERR,ERR,ARRBV,OBJBK,VAL,ERR,ARRAV,ARRAV,ARRAV,ERR},
			/*ARRAV*/{ERR,ERR,ERR,ARRBV,ERR,ERR,VAL,ERR,ERR,ERR,ERR,ERR},
			/*OBJBK*/{OBJAK,OBJAK,ERR,ERR,ERR,ERR,ERR,VAL,ERR,ERR,ERR,ERR},
			/*OBJAK*/{ERR,ERR,OBJBV,ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR},
			/*OBJBV*/{OBJAV,OBJAV,ERR,ERR,ARRBV,OBJBK,ERR,ERR,OBJAV,OBJAV,OBJAV,ERR},
			/*OBJAV*/{ERR,ERR,ERR,OBJBK,ERR,ERR,ERR,VAL,ERR,ERR,ERR,ERR},
			/*VAL*/{},//没有后续状态,遇见此状态时弹出状态栈中的状态计算当前状态,占位，方便后期添加
			/*EOF*/{},//没有后续状态，占位，方便后期添加
			/*ERR*/{}//没有后续状态，占位，方便后期添加
	};
	//Token输入操作列表
	/*INPUT —— STR NUM DESC SPLIT ARRS OBJS ARRE OBJE FALSE TRUE NIL BGN*/
	public static final Method[] TKOL = {
		null,null,null,null,OPT.ARRS,OPT.OBJS,null,null,null,null,null,null
	};
	//目标状态转换操作列表
	/*TO:BGN ARRBV ARRAV OBJBK OBJAK OBJBV OBJAV VAL EOF ERR*/
	public static final Method[] STOL = {
		null,null,OPT.ARRAV,null,OPT.OBJAK,null,OPT.OBJAV,OPT.VAL,null,null
	};
	//期望Token描述列表
	/*FROM:BGN ARRBV ARRAV OBJBK OBJAK OBJBV OBJAV VAL EOF ERR*/
	public static final String[] ETS = {
		getExpectStr(BGN), getExpectStr(ARRBV), getExpectStr(ARRAV), getExpectStr(OBJBK), getExpectStr(OBJAK), getExpectStr(OBJBV), getExpectStr(OBJAV),TOK.castTokType2LocalStr(TOK.EOF),TOK.castTokType2LocalStr(TOK.EOF),TOK.castTokType2LocalStr(TOK.EOF)
	};
	//状态描述列表
	/*BGN ARRBV ARRAV OBJBK OBJAK OBJBV OBJAV VAL EOF ERR*/
	public static final String[] STS = {
		"解析开始","数组待值","数组得值","对象待键","对象得键","对象待值","对象得值","得最终值","解析结束","异常错误"
	};
	//将状态数值转换为状态描述
	public static String castLocalStr(Integer s){
		return STS[s];
	}
	//获取期望Token描述字符串
	public static String getExpectStr(Integer old){
		StringBuffer sb = new StringBuffer();
		for(int i=0;i
这个类里面分为这么几部分：

  1. 状态的定义，全是静态常量，凑了个整数，正好10个
  2. 一个状态转换矩阵的定义，行是状态，列是输入的Token，整个矩阵的意义是：该行的状态在遇见该列的Token类型时转换为什么状态
  3. 两个操作列表，一个是Token输入操作列表，意思是，当输入为这个类型的Token时，我要执行一个什么操作；还有一个是目标状态转换操作列表，意思是，如果转换为这个状态的话，我会执行什么操作。所映射的操作与OPT和Operator这两个类相关，后面再说……
  4. 一个期望Token描述列表以及对应的一个实现方法，这个列表里存的是，当前状态下输入哪些Token是正确的，其实也就是从状态转换矩阵里，把状态对应行中不是ERR(错误)的Token取出来连成字符串，这个字符串列表是为报错用的……如果出现错误，我们就可以提示用户：在哪一行哪一列，期望什么，但是却得到了什么……
  5. 将状态转换为字符串的列表及方法，对应数字就能找到相应的描述，再对应上面那个图，大体上就会有感觉了……

相信，有了这个描述，再加上这个状态转换矩阵对应上面状态转换图一起看，大家应该都会对状态机有一个整体的概念和把握了……

接下来就是状态机的实现了……看StateMachine类，反而很简单，就一个方法……比起词法解析来代码少多了……先看一下内容：

package com.huaying1988.multTravJsonParse.syntax;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import com.huaying1988.multTravJsonParse.lex.JsonLex;
import com.huaying1988.multTravJsonParse.lex.Token;
import com.huaying1988.multTravJsonParse.lex.UnexpectedException;

/**
 * 语法状态机，负责状态转换，以及相关操作的调用
 * @author huaying1988.com
 *
 */
public class StateMachine {
	private JsonLex lex = null;
	private Operator opt = null;
	private Integer status = null;
	public StateMachine(String str){
		if (str == null)
			throw new NullPointerException("语法解析构造函数不能传递null");
		lex = new JsonLex(str);
		opt = new Operator(lex);
	}
	
	public Object parse(){
		Token tk = null;
		status = STATE.BGN;
		Integer oldStatus = status;
		while((tk=lex.next())!=Token.EOF){
			if(tk == null){
				throw lex.generateUnexpectedException("发现不能识别的token：“" + lex.getCurChar() + "”");
			}
			if(status == STATE.VAL || status == STATE.EOF || status == STATE.ERR){
				throw lex.generateUnexpectedException("当前状态【"+STATE.castLocalStr(oldStatus)+"】,期待【结束】;却返回"+tk.toLocalString());
			}
			oldStatus = status;
			status = STATE.STM[oldStatus][tk.getType()];
			if(status == STATE.ERR){
				throw lex.generateUnexpectedException("当前状态【"+STATE.castLocalStr(oldStatus)+"】,期待【"+(STATE.ETS[oldStatus]==null?"结束":STATE.ETS[oldStatus])+"】;却返回"+tk.toLocalString());
			}
			try {
				Method m = STATE.TKOL[tk.getType()];
				if(m!=null){//输入Token操作
					status = (Integer)m.invoke(opt, oldStatus, status, tk);
				}
				m = STATE.STOL[status];
				if(m!=null){//目标状态操作
					status = (Integer)m.invoke(opt, oldStatus, status, tk);
				}
			} catch (IllegalArgumentException e) {
				throw lex.generateUnexpectedException("【反射调用】传入非法参数",e);
			} catch (IllegalAccessException e) {
				throw lex.generateUnexpectedException("【反射调用】私有方法无法调用",e);
			} catch (InvocationTargetException e) {
				if(e.getTargetException() instanceof UnexpectedException){
					throw (UnexpectedException)e.getTargetException();
				}else{
					throw lex.generateUnexpectedException("运行时异常",e);
				}
			}
		}
		return opt.getCurValue();
	}
}
俗话说，浓缩的都是精华啊……除了构造函数初始化，就剩下parse方法了……JSON.java类就是调的这个方法……看来这就已经到了核心方法了！

然而这个核心方法也没几行啊……核心内容就是一个while循环，从词法分析器的上游获得Token作为输入……看看是不是文件结束类型的Token，是，就跳出循环，返回操作对象中的当前值……

每次循环，开始先做一些检查，该报错的报错，根据状态转换矩阵进行状态转换，当前得到三个参数，一个旧状态，一个输入的Token，一个新状态，再做一次ERR检查，该报错的报错……

然后，看看Token操作列表里有该Token类型相关的绑定操作没，有的话执行，没有的话跳过；再看看状态操作列表里有没有目标状态绑定的操作，有的话执行，传值都是这三个参数：一个旧状态，一个输入的Token，一个新状态。

这个地方用的反射执行，为啥没用接口类的多重实现的方式呢？因为那样写太不紧凑了……如果我每一个操作都写一个操作接口的操作类实现的话，我要写好多的类，这样一点都不漂亮，而且把代码搞得很分散，根本不容易看，更不好给大家讲解不是？所以，用反射的方式，一个类里可以包含所有你想要的方法，所有的实现都在一个类里，多漂亮……这就叫用一种形式上的完美来代替另一种形式上的完美……

上篇文章我说过了，语法分析是一道坎……这个核心弄懂了，大约整个解析器就弄得差不多了……不管你信不信，反正经过我的讲解之后，那个同事把状态机、状态转换矩阵突然茅塞顿开般的弄懂了，这是很大的进步……

然而，后面还有一道坎，你懂得~

配套堆栈处理

状态机有了，但是总要用它来干点事，那就是对应的操作了……

刚才已经看到了，所有的操作映射都挂在了STATE类里……

其实到这一块，就跟上一篇文章又很像了……

因为语法分析上，yacc/bison用了一种通用的抽象描述手段，语法树；而我用了一种通用的抽象解析手段，状态机……

其本质是一样的……最后回归到操作上，连形式也一样了……

先看一下操作类Operator.java：

package com.huaying1988.multTravJsonParse.syntax;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

import com.huaying1988.multTravJsonParse.lex.JsonLex;
import com.huaying1988.multTravJsonParse.lex.TOK;
import com.huaying1988.multTravJsonParse.lex.Token;

/**
 * 该类负责实际操作
 * 
 * @author huaying1988.com
 * 
 */
public class Operator {
	private JsonLex lex = null;
	private Stack statusStack = new Stack();
	private Object curValue = null;
	private Stack keyStack = new Stack();
	private Stack objStack = new Stack();
	private Object curObj = null;

	public Object getCurObj() {
		return curObj;
	}

	public Operator(JsonLex lex) {
		this.lex = lex;
	}

	public Object getCurValue(){
		return curValue;
	}
	
	public Integer objs(Integer from, Integer to, Token input) {
		if (from != STATE.BGN) {
			statusStack.push(from);
		}
		curObj = new HashMap();
		objStack.push(curObj);
		return to;
	}
	
	public Integer arrs(Integer from, Integer to, Token input) {
		if (from != STATE.BGN) {
			statusStack.push(from);
		}
		curObj = new ArrayList();
		objStack.push(curObj);
		return to;
	}

	@SuppressWarnings("unchecked")
	public Integer val(Integer from, Integer to, Token input) {
		switch (input.getType()) {
			case TOK.ARRE:
			case TOK.OBJE:
				curObj = objStack.pop();
				curValue = curObj;
				break;
			case TOK.TRUE:
			case TOK.FALSE:
			case TOK.NIL:
			case TOK.NUM:
			case TOK.STR:
				curValue = getRealValue(input);
				break;
		}
		if (statusStack.isEmpty()) {
			return STATE.EOF;
		}else{
			Integer s = statusStack.pop();
			if (s == STATE.ARRBV) {
				curObj = objStack.peek();
				((List) curObj).add(curValue);
				s = STATE.ARRAV;
			} else if (s == STATE.OBJBV) {
				curObj = objStack.peek();
				((Map) curObj).put(keyStack.pop(), curValue);
				s = STATE.OBJAV;
			}
			return s;
		}
	}

	private Object getRealValue(Token input) {
		Object value = null;
		try {
			value = input.getRealValue();
		} catch (RuntimeException e) {
			lex.generateUnexpectedException("字符串转换错误", e);
		}
		return value;
	}

	@SuppressWarnings("unchecked")
	public Integer arrav(Integer from, Integer to, Token input) {
		curValue = getRealValue(input);
		((List) curObj).add(curValue);
		return to;
	}

	public Integer objak(Integer from, Integer to, Token input) {
		keyStack.push(getRealValue(input));
		return to;
	}

	@SuppressWarnings("unchecked")
	public Integer objav(Integer from, Integer to, Token input) {
		curValue = getRealValue(input);
		((Map) curObj).put(keyStack.pop(), curValue);
		return to;
	}
}
看过 上一篇文章的同学会觉得很眼熟吧，眼熟的东西有这么几个属性：curObj、curValue、objStack 
  
 
  
不认识的有这么两个属性：stateStack、keyStack……
 
  
学习好的同学可能记起来了我上一篇文章中说的话：yacc/bison内置有两个栈，一个状态栈，一个值栈
 
  
而这两个Stack就是传说中的这两个栈……一一暴露在了我们的眼前……
 
  
我思考前后，觉得还是把这个栈放在这个类里比较好，因为想想yacc/bison里面这些东西都是紧密相关的……
 
  
因为这两个栈本来也不属于状态机的东西……
 
  
好了，除了这几个属性，还有get方法，剩下的，都是用于操作的方法了……
 
  
什么出栈入栈啦……来回赋值啦……put、add啦……跟上篇文章写的js生成如出一辙，异曲同工……
 
  
唯一与状态机沾点边的就是val这个操作，这个操作会在状态栈里拿出一个状态来进行运算后，返回一个新的状态作为状态机的新状态……
 
  
这是很重要的一步，也就是在遍历表达式树状结构的时候必要的一步状态回溯操作……学过数据结构的好好想想就能想明白……
 
  
至于其他的，没什么好说的……最后再看看OPT.java这个类：
 
  
 
  
package com.huaying1988.multTravJsonParse.syntax;

import java.lang.reflect.Method;

import com.huaying1988.multTravJsonParse.lex.Token;

/**
 * 保存操作相关的静态常量
 * @author huaying1988.com
 *
 */
public class OPT {
	public static final Method VAL = getMethod("val");
	public static final Method ARRAV = getMethod("arrav");
	public static final Method OBJAK = getMethod("objak");
	public static final Method OBJAV = getMethod("objav");
	public static final Method ARRS = getMethod("arrs");
	public static final Method OBJS = getMethod("objs");

	public static Method getMethod(String methodName){
		Method m =  null;
		try {
			m = Operator.class.getMethod(methodName, new Class[]{Integer.class,Integer.class,Token.class});
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		}
		return m;
	}
}

这个类里就定义了Operator类中这些方法的静态映射……用来反射调用的时候用的……其中为了简便起见，还写了一个配套的方法返回相应的Method对象…… 
  
 
  

 
  
好了，到此为止，整个JSON解析器就讲完了……这个JSON解析器返回的是List、Map的嵌套结构对象……其实本来还想继续实现一个返回JavaBean对象得JSON解析方法……
 
  
这要通过反射注入的方式来设置对象的属性值，比生成List、Map嵌套结构要略微复杂一些难度的……但是想来，原理已经弄清楚了,具体实现到哪一步也完全看心情了吧……
 
  
是时候来个尾声了呢……
 
  
下载链接
 
  
按照惯例，最后还是要给个下载链接的~
 
  
后话
 
  
那个求问的同事给了我一个大大的服……然而，我到现在也没去成阿里啊……哈哈哈哈……
 
  

 
  

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(编译原理)

        

            

                
    
                    
  • 【编译原理】方舟编译技术课程 — 词法分析
                        CSU_THU_SUT
编译原理编译器编译原理llvm
                        
    打开目录阅读更佳参考视频：方舟·编译技术入门与实战以及西交冯博琴老师的相关视频编译的过程包括词法分析（分析程序符号）、语法分析（分析语法单位）、中间代码生成、代码优化和目标代码生成。一、编译过程各部分的任务（1）词法分析：输入源程序，扫描分解源程序字符串，识别五类符号，包括定义符、标识符、运算符、界符和常数，转为单词符号。（2）语法分析：在词法分析基础上，将单词符号转为语法单位（如短句、子句、句子
    
                    
    • 
                    
  • 包含所有的计算机视频教程
                        rart2008
程序人生windows移动开发企业应用网络分布式应用asp.net
                        
    计算机视频教程http://www.study66.cn/soft/show.asp?id=1237北京师范大-多媒体视频http://www.study66.cn/soft/show.asp?id=1240北京理工大学编译原理串讲http://www.study66.cn/soft/show.asp?id=1241北京大学计算机网络视频教程http://www.study66.cn/soft/s
    
                    
    • 
                    
  • 程序员心中的一道坎：主存的编址与计算和串并联系统！
                        冰河团队

                        
    写在前面很多小伙伴认为程序员就是写写代码，不需要了解计算机底层的知识和原理。其实，这种观点是错误的。如果你想突破程序员的职业发展瓶颈，计算机硬件、操作系统原理、编译原理等是一定要掌握的知识。而【冰河技术】微信公众号的【程序员进阶系列】专题就是要系统的向大家分享程序员进阶需要掌握的各项知识技能。今天，我们来聊聊一个让程序员很头疼的话题：计算机中的主存是如何进行编址和计算的？主存编址与计算这里，小伙伴
    
                    
    • 
                    
  • 树数据结构（Tree Data Structures）的全面指南：深度解析、算法实战与应用案例
                        Chauvin912
数据结构科普数据结构算法
                        
    树数据结构（TreeDataStructures）的全面指南：深度解析、算法实战与应用案例引言树数据结构（TreeDataStructures）作为计算机科学中的基石之一，以其独特的层次结构和分支特性，在众多领域发挥着关键作用。从文件系统的组织到数据库的索引，从编译原理的语法分析到人工智能的决策制定，树数据结构无处不在。本文将深入探讨树数据结构的基本概念、类型、遍历方式及其在实际应用中的广泛案例。
    
                    
    • 
                    
  • 2018-09-07
                        Maymomo

                        
    编译原理Ch1概念编译程序本质上是一个翻译程序，将一门源语言(高级语言)翻译成功能等价的低级语言(汇编语言，机器语言等)的程序。编译程序由八部分组成：词法分析程序语法分析程序语义分析程序中间代码生成程序代码优化程序目标代码生成程序表格管理程序出错处理程序词法分析顺序读入源程序文件，解析出一个个的单词.我的理解是将语言的保留字，标识符，运算符和数值等提取出来。如下简单的C代码(假设不经历预处理器处理
    
                    
    • 
                    
  • C++竞赛初阶L1-14-第六单元-数组(31~33课)541: T456471 计算书费
                        麓小墨哥
c++免费文章c++开发语言青少年编程算法数据结构
                        
    题目内容下面是一个图书的单价表：计算概论28.9元/本数据结构与算法32.7元/本数字逻辑45.6元/本C++程序设计教程78元/本人工智能35元/本计算机体系结构86.2元/本编译原理27.8元/本操作系统43元/本计算机网络56元/本JAVA程序设计65元/本依次给定每种图书购买的数量，编程计算应付的总费用。输入格式输入一行，含10个非负整数，每两个整数之间有一个空格。第i个整数表示要购买上述
    
                    
    • 
                    
  • Vue 模版编译原理
                        I will.874
vue.jsjavascript前端
                        
    当我们使用Vue编写完一个组件以后，Vue会根据模版编译一个render函数，调用render函数生成虚拟DOM，然后将虚拟DOM映射成真实DOM当数据发生变化时，Vue会触发更新视图，调用render函数返回新的虚拟DOM，对比新旧虚拟DOM，修改真实DOM，从而更新页面在此期间，有以下4个关键步骤：模版编译。生成渲染函数render执行render函数生成虚拟DOM首次渲染，根据虚拟DOM生成
    
                    
    • 
                    
  • 【编译原理】一篇就够了——学习笔记与课程实验超详细整理
                        一棵___大树
编译原理学习笔记学习算法
                        
    ⭐⭐⭐⭐⭐⭐Github主页https://github.com/A-BigTree更多学习笔记链接https://github.com/A-BigTree/college_assignment编译原理实验https://github.com/A-BigTree/college_assignment/compiler_Experiment如果可以，麻烦各位看官顺手点个star~如果文章对你有所帮助
    
                    
    • 
                    
  • 解析器模式详解
                        d303577562
设计模式设计模式
                        
    1.简介在软件开发中，会遇到有些问题多次重复出现，而且有一定的相似性和规律性。如果将它们归纳成一种简单的语言，那么这些问题实例将是该语言的一些句子，这样就可以用“编译原理”中的解释器模式来实现了。虽然使用解释器模式的实例不是很多，但对于满足以上特点，且对运行效率不是很高的应用实例，如果用解释器模式来实现，其效果是非常好的。2.定义解释器（Interpreter）模式的定义：给分析对象定义一个语言，
    
                    
    • 
                    
  • 用python+pyqt5手工编写一个含交互界面的简易的词法分析器
                        x1Nge.
学习记录python
                        
    python+pyqt5手工编写一个含交互界面的简易词法分析器@author：x1nge.编译原理基础实验基础在之前的一篇博文中我记录了一个不含交互界面的简易词法分析器程序编写内容点击此处查看在本文我将用pyqt5写一个简单的交互界面，也修改了部分代码使得程序更加完整。具体实验分析本文全部源码见本文末尾，上次编写的不含交互界面的源码也可点此处下载交互界面可以用QtDesigner快速编写，或者自己
    
                    
    • 
                    
  • 今日总结
                        薛灵均

                        
    1.今日工作感觉还行吧。2.刷了抖音和知乎，练了口语。3.读了《线》10-12章4.做了一会儿矫正动作5.听了歌，印象比较深刻的是《大地》《女人花》《月亮惹的祸》《花心》《心如止水》《屋顶》《我曾》6.看了一点点java和编译原理7.决定明天开始恢复excel的学习8.今天吃的鸭翅好吃9.成年人了，该学会哭过就整理好情绪好好反省自己。10.明天做学编译原理吧，相信自己。还要开始着手面试的事了。按自
    
                    
    • 
                    
  • java设计模式之解释器模式
                        劉鵬杰
JAVA设计模式java设计模式解释器模式
                        
    解释器模式（InterpreterPattern）1.基本介绍在编译原理中，一个算术表达式通过词法分析器形成词法单远，而这些词法单远再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树，（词法分析器和语法分析器都可以看做是解释器）解释器模式是指给定一个语言（表达式），定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）。2.应用场景可以将一个需要解释执行的语言
    
                    
    • 
                    
  • 程序员泛滥的时代，怎么样才能让自己脱颖而出？
                        Java自闭师

                        
    由于LZ本人是Java后端开发出身，因此所推荐的学习内容是JavaWeb和Java后端开发的路线，非JavaWeb和Java后端开发的同学请适当参考其学习思想即可，切勿照搬。2、下面的推荐内容，目的是让你尽快成为一个可以参加工作的Java开发者，更适用于处于待业状态，准备转行Java的同学。如果你是在校学生，务必要在学好基础（比如计算机系统、算法、编译原理等等）的前提下，再考虑去进行下面的学习。对
    
                    
    • 
                    
  • 编译原理（三）词法分析
                        Cookie__C

                        
    词法分析词法分析是编译的第一个阶段，它的主要任务是从左到右逐个字符地对源程序进行扫描，产生一个个单词序列。词法分析阶段设计的主要问题是字符串（单词）的识别问题。具体说，如何判定任意的一个字符串是否为合法字符串(单词)的问题。字符串（单词）集合可用不同的工具来表示，常见的有：单词的描述技术：正规式。识别机制：有穷自动机（有限自动机）。因此，要研究如何从正规表达式或自动机构造出相应的单词识别器的问题。
    
                    
    • 
                    
  • STM32必备知识点（面试和工作用的到）
                        树的编程知识屋
嵌入式基础stm32求职招聘单片机
                        
    STM32必备知识点（面试和工作用的到）文章目录STM32必备知识点（面试和工作用的到）前言嵌入式C基础一、位操作1.不改变其他位的值的状况下，对某几个位进行设值2.移位操作提高代码的可读性:将第pinpos位设置为13.~取反操作使用技巧4.举例：二、ifdef条件编译三、extern变量申明二、编译原理1、Gcc编译的C语言程序占用的内存分为哪几个部分？三、STM32资料1、常用小知识2、基础
    
                    
    • 
                    
  • 编译原理-递归下降分析法-c简单实现
                        都灵的夏天_

                        
    一、实验目的：根据某一文法编制调试递归下降分析程序，以便对任意输入的符号串进行分析。本次实验的目的主要是加深对递归下降分析法的理解。二、实验预习提示1、递归下降分析法的功能词法分析器的功能是利用函数之间的递归调用模拟语法树自上而下的构造过程。2、递归下降分析法的前提改造文法：消除二义性、消除左递归、提取左因子，判断是否为LL（1）文法，3、递归下降分析法实验设计思想及算法为G的每个非终结符号U构造
    
                    
    • 
                    
  • 深入了解C++：底层编译原理
                        程韬123
linux运维c++缓存开发语言
                        
    进程的虚拟空间划分任何编程语言，都会产生两样东西，指令和数据。.exe程序运行的时候会从磁盘被加载到内存中，但是不能直接加载到物理内存中。Linux会给当前进程分配一块空间，比如x8632位linux环境下会给进程分配2^32(4G)大小的空间，这个空间被叫做【进程的虚拟地址空间】，进程的虚拟地址空间其实并不存在，从底层来看它不过是内核创建的一系列数据结构而已。以x8632位linux为例，讲解进
    
                    
    • 
                    
  • 深入了解C++：底层编译原理（二）
                        程韬123
c++开发语言
                        
    C++文件需要经历编译和链接两大步骤才能生成可执行文件。编译会生成二进制可重定位的目标文件，其中的重定位指的是符号重定位，发生了链接阶段。二进制可重定位的目标文件：也就是我们通常所说的.o，.obj文件。二进制文件构成：二进制文件就是.o文件，其中的内容除了elf文件头，还由各个段组成，有些段和内存空间个段可以匹配，比如.text,.data.,.bss段。objdump-s和readelf-S是
    
                    
    • 
                    
  • (三)JVM成神路之全面详解执行引擎子系统与JIT即时编译原理
                        竹子爱熊猫
JVMjava高并发编程架构
                        
    引言执行引擎子系统是JVM的重要组成部分之一，在JVM系列的开篇曾提到：JVM是一个架构在平台上的平台，虚拟机是一个相似于“物理机”的概念，与物理机一样，都具备代码执行的能力。但虚拟机与物理机最大的不同在于：物理机的执行引擎是直接建立在处理器、高速缓存、平台指令集与操作系统层面上的，物理机的执行引擎可以直接调用各处资源对代码进行直接执行，而虚拟机则是建立在软件层面上的平台，它的执行引擎则是负责解释
    
                    
    • 
                    
  • JVM成神路之全面详解执行引擎子系统、JIT即时编译原理与分派实现
                        头顶假发
程序员Java编程jvmjavalinux
                        
    引言执行引擎子系统是JVM的重要组成部分之一，在JVM系列的开篇曾提到：JVM是一个架构在平台上的平台，虚拟机是一个相似于“物理机”的概念，与物理机一样，都具备代码执行的能力。但虚拟机与物理机最大的不同在于：物理机的执行引擎是直接建立在处理器、高速缓存、平台指令集与操作系统层面上的，物理机的执行引擎可以直接调用各处资源对代码进行直接执行，而虚拟机则是建立在软件层面上的平台，它的执行引擎则是负责解释
    
                    
    • 
                    
  • 疫情爆发前 我因流感被隔离了
                        冷冷的方格田

                        
    时间：2019年末记录初衷：可能因为印象比较深刻，给我身体和精神上带来了较大的折磨，并且紧挨着就发生了新冠（以下是正文，没有太多修辞，仅仅是个人经历的一次记录）12月9日daybegin早上起来忽然感觉头昏脑胀，喉咙不知不明的痛。不过，作为一个在校大学生，作业任务让我很快压过了生病的念头。今天的计划是把编译原理的实验报告写完，这事就算结束了。早早的起床，洗漱吃饭，到自习室。实验报告写了一半，困意来
    
                    
    • 
                    
  • Makefile编译原理 make 中的路径搜索_2
                        嵌入式_笔记
Linux驱动linux
                        
    一.make中的路径搜索VPATH变量和vpath关键字同时指定搜索路径。实验1VPATH和vpath同时指定搜索路径mhr@ubuntu:~/work/makefile1/18$tree.├──inc│└──func.h├──main.c├──makefile├──src1│└──func.c└──src2└──func.cmakefileVPATH:=src1CFLAGS:=-Iincvpat
    
                    
    • 
                    
  • Makefile编译原理 make 中的路径搜索_1
                        嵌入式_笔记
Linux驱动linux
                        
    一.make中的路径搜索问题：在实际的工程项目中，所有的源文件和头文件都放在同一个文件夹中吗？实验1：VPATH引子mhr@ubuntu:~/work/makefile1/17$lltotal28drwxrwxr-x4mhrmhr4096Apr2200:46./drwxrwxr-x7mhrmhr4096Apr2200:32../drwxrwxrwx2mhrmhr4096Jan232018inc/-
    
                    
    • 
                    
  • Makefile编译原理 make的隐性规则
                        嵌入式_笔记
Linux驱动数据库服务器运维
                        
    一.makefile中的同名目标下面程序怎么执行？为什么？实验1：makefile中出现同名目标时.PHONY:allall:@echo"command-1"all:@echo"command-2"VAR:=testall:@echo"all:$(VAR)"mhr@ubuntu:~/work/makefile1$makeallmakefile:12:warning:overridingrecipe
    
                    
    • 
                    
  • 【软件设计师】——编译原理
                        栉风沐雪
软件设计师开发语言汇编软件工程
                        
    编译系统的结构词法分析/扫描(Scanning)从左向右逐行扫描源程序的字符，识别出各个单词，确定单词的类型。将识别出的单词转换成统一的机内表示，词法单元(token)形式：token:单词类型种别种别码关键字program,if,else…一词一码标识符变量名，数组名，记录名…多词一码常量整型，浮点型，字符型…一型一码运算符算术、关系、逻辑一词\一型一码界限符;()={}…一词一码语法分析(pa
    
                    
    • 
                    
  • 《编译原理》
                        曹元_

                        
    第一章编译引论1、编译程序：将某一种程序设计语言写的程序翻译成等价的另一种语言的程序的程序2、源语言：用来编写源程序的语言（汇编，高级程序设计语言）3、源程序：用源语言写的程序4、目标语言：目标程序描述的语言5、目标程序：源程序经过编译后生成的程序6、宿主语言：编译程序的实现语言7、宿主机：编译程序的运行环境8、分类：解释程序【接受某语言的源程序将其直接翻译成目标代码且执行】；编译程序【接受某语言
    
                    
    • 
                    
  • 编译原理研究性学习专题 2——递归下降语法分析设计原理与实现
                        dor.yang
课程作业记录博客学习java前端编译原理递归下降
                        
    1实验内容完成以下描述赋值语句的LL(1)文法的递归下降分析程序G[S]:S→V=EE→TE’E’→ATE’|eT→FT’T’→MFT’|EF→(E)|iA→+|-M→*|/V→i设计说明：终结符号i为用户定义的简单变量，即标识符的定义。2实验要求（1）输入串应是词法分析的输出二元式序列，即某算术表达式“专题1”的输出结果，输出为输入串是否为该文法定义的算术表达式的判断结果；（2）递归下降分析程序
    
                    
    • 
                    
  • 编译原理（九）——递归下降法
                        很注重数学和821
编译原理
                        
    背景：自定向下的语法分析方法，LL(1)是一种非常直观的方法，它的分析过程是按照句子的定义来进行的，也就是说从开始符出发对要分析的串进行推导，如果推导成功就证明这个被分析的串是一个合法的句子，否则的话就有语法错误，但是在推导过程中，对文法进行了一些限定，保证推导过程是唯一的。总体上说，LL(1)就是在选择规则的时候加入了约束条件，考虑到输入流中的第一个符号，以及推导过程中的非终极符的规则选择，只有
    
                    
    • 
                    
  • 编译原理 实验2 语法分析——递归下降分析器
                        学而时习之，不亦说乎？

                        
    目录标题一、核心代码1.题目要求2.代码实现3.运行结果：二、实现加，减，乘，除运算的表达式文法1.题目要求2.代码实现3.运行结果一、核心代码1.题目要求练习构造递归下降语法分析程序的方法，熟悉上下文无关文法的使用，加深对课堂教学的理解；提高语法分析方法的实践能力文法G[E]:E→E+T|TT→T*F|FF→i|(E)消除左递归后：E→TXX→+TX|^T→FYY→*FY|^F→i|(E)要求：
    
                    
    • 
                    
  • 编译原理——实验贰——递归下降语法分析器的构建
                        赴约如期

                        
    一、实验要求运用递归下降法，针对给定的上下文无关文法，给出实验方案。预估实验中可能出现的问题。二、实验方案1、构造LL(1),通过设计、编制、调试递归下降语法分析程序，对输入的符号串进行分析匹配，观察输入符号串是否为给定文法的句子。2、根据LL(1)写程序三、预估问题预估问题：LL（1）构造失败，程序报错理论基础：1、递归下降分析程序的实现思想是：识别程序由一组子程序组成。每个子程序对应于一个非终
    
                    
    • 
                                
  • log4j对象改变日志级别
                                    3213213333332132
javalog4jlevellog4j对象名称日志级别
                                    
    log4j对象改变日志级别可批量的改变所有级别，或是根据条件改变日志级别。 
 
log4j配置文件： 
 
 

log4j.rootLogger=ERROR,FILE,CONSOLE,EXECPTION
 
#log4j.appender.FILE=org.apache.log4j.RollingFileAppender
log4j.appender.FILE=org.apache.l
    
                                
    • 
                                
  • elk+redis 搭建nginx日志分析平台
                                    ronin47
elasticsearchkibanalogstash
                                    
                  elk+redis 搭建nginx日志分析平台 
logstash,elasticsearch,kibana 怎么进行nginx的日志分析呢？首先，架构方面，nginx是有日志文件的，它的每个请求的状态等都有日志文件进行记录。其次，需要有个队 列，redis的l
    
                                
    • 
                                
  • Yii2设置时区
                                    dcj3sjt126com
PHPtimezoneyii2
                                    
    时区这东西，在开发的时候，你说重要吧，也还好，毕竟没它也能正常运行，你说不重要吧，那就纠结了。特别是linux系统，都TMD差上几小时，你能不痛苦吗？win还好一点。有一些常规方法，是大家目前都在采用的1、php.ini中的设置，这个就不谈了，2、程序中公用文件里设置，date_default_timezone_set一下时区3、或者。。。自己写时间处理函数，在遇到时间的时候，用这个函数处理（比较
    
                                
    • 
                                
  • js实现前台动态添加文本框，后台获取文本框内容
                                    171815164
文本框
                                    
    

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://w
    
                                
    • 
                                
  • 持续集成工具
                                    g21121
持续集成
                                    
            持续集成是什么？我们为什么需要持续集成？持续集成带来的好处是什么？什么样的项目需要持续集成？...        持续集成(Continuous integration ,简称CI)，所谓集成可以理解为将互相依赖的工程或模块合并成一个能单独运行
    
                                
    • 
                                
  • 数据结构哈希表(hash)总结
                                    永夜-极光
数据结构
                                    
    1.什么是hash 
来源于百度百科: 
Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 
  

    
                                
    • 
                                
  • 乱七八糟
                                    程序员是怎么炼成的

                                    
    eclipse中的jvm字节码查看插件地址： 
http://andrei.gmxhome.de/eclipse/ 
安装该地址的outline 插件  后重启，打开window下的view下的bytecode视图 
http://andrei.gmxhome.de/eclipse/ 
  
jvm博客： 
http://yunshen0909.iteye.com/blog/2
    
                                
    • 
                                
  • 职场人伤害了“上司” 怎样弥补
                                    aijuans
职场
                                    
     由于工作中的失误，或者平时不注意自己的言行“伤害”、“得罪”了自己的上司，怎么办呢？ 
　　在职业生涯中这种问题尽量不要发生。下面提供了一些解决问题的建议： 
　　一、利用一些轻松的场合表示对他的尊重 
　　即使是开明的上司也很注重自己的权威，都希望得到下属的尊重，所以当你与上司冲突后，最好让不愉快成为过去，你不妨在一些轻松的场合，比如会餐、联谊活动等，向上司问个好，敬下酒，表示你对对方的尊重，
    
                                
    • 
                                
  • 深入浅出url编码
                                    antonyup_2006
应用服务器浏览器servletweblogicIE
                                    
    出处：http://blog.csdn.net/yzhz  杨争   
http://blog.csdn.net/yzhz/archive/2007/07/03/1676796.aspx 
 
一、问题： 
        编码问题是JAVA初学者在web开发过程中经常会遇到问题，网上也有大量相关的
    
                                
    • 
                                
  • 建表后创建表的约束关系和增加表的字段
                                    百合不是茶
标的约束关系增加表的字段
                                    
      
下面所有的操作都是在表建立后操作的,主要目的就是熟悉sql的约束,约束语句的万能公式 
  
1,增加字段(student表中增加 姓名字段) 
  
alter table 增加字段的表名 add  增加的字段名   增加字段的数据类型

  alter table student add name varchar2(10);
 
  
&nb
    
                                
    • 
                                
  • Uploadify 3.2 参数属性、事件、方法函数详解
                                    bijian1013
JavaScriptuploadify
                                    
    一.属性     
属性名称   
默认值   
说明     
auto   
true   
设置为true当选择文件后就直接上传了，为false需要点击上传按钮才上传。     
buttonClass   
”   
按钮样式     
buttonCursor   
‘hand’   
鼠标指针悬停在按钮上的样子     
buttonImage   
null   
浏览按钮的图片的路
    
                                
    • 
                                
  • 精通Oracle10编程SQL(16)使用LOB对象
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用LOB对象
 */
--LOB(Large Object)是专门用于处理大对象的一种数据类型，其所存放的数据长度可以达到4G字节
--CLOB/NCLOB用于存储大批量字符数据，BLOB用于存储大批量二进制数据，而BFILE则存储着指向OS文件的指针

/*
 *综合实例
 */
--建立表空间 
--#指定区尺寸为128k,如不指定，区尺寸默认为64k 
CR
    
                                
    • 
                                
  • 【Resin一】Resin服务器部署web应用
                                    bit1129
resin
                                    
    工作中，在Resin服务器上部署web应用，通常有如下三种方式： 
  
 
 配置多个web-app 
 配置多个http id 
 为每个应用配置一个propeties、xml以及sh脚本文件 
 配置多个web-app 
  
 
 在resin.xml中,可以为一个host配置多个web-app 
 
  
<cluster id="app&q
    
                                
    • 
                                
  • red5简介及基础知识
                                    白糖_
基础
                                    
      
 
 简介 
 
  
Red5的主要功能和Macromedia公司的FMS类似，提供基于Flash的流媒体服务的一款基于Java的开源流媒体服务器。它由Java语言编写，使用RTMP作为流媒体传输协议，这与FMS完全兼容。它具有流化FLV、MP3文件，实时录制客户端流为FLV文件，共享对象，实时视频播放、Remoting等功能。用Red5替换FMS后,客户端不用更改可正
    
                                
    • 
                                
  • angular.fromJson
                                    boyitech
AngularJSAngularJS 官方APIAngularJS API
                                    
    angular.fromJson   描述:   把Json字符串转为对象    使用方法:   angular.fromJson(json);   参数详解:      Param Type Details   json 
string  
JSON 字符串      返回值:   对象, 数组, 字符串 或者是一个数字   示例:   
<!DOCTYPE HTML>
<h
    
                                
    • 
                                
  • java-颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I
                                    bylijinnan
java
                                    
    

public class ReverseWords {

	/**
	 * 题目：颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I.词以空格分隔。
	 * 要求：
	 * 1.实现速度最快,移动最少
	 * 2.不能使用String的方法如split,indexOf等等。
	 * 解答：两次翻转。
	 */
	publ
    
                                
    • 
                                
  • web实时通讯
                                    Chen.H
Web浏览器socket脚本
                                    
    关于web实时通讯，做一些监控软件。 
由web服务器组件从消息服务器订阅实时数据，并建立消息服务器到所述web服务器之间的连接，web浏览器利用从所述web服务器下载到web页面的客户端代理与web服务器组件之间的socket连接，建立web浏览器与web服务器之间的持久连接；利用所述客户端代理与web浏览器页面之间的信息交互实现页面本地更新，建立一条从消息服务器到web浏览器页面之间的消息通路
    
                                
    • 
                                
  • [基因与生物]远古生物的基因可以嫁接到现代生物基因组中吗?
                                    comsci
生物
                                    
     
 
      大家仅仅把我说的事情当作一个IT行业的笑话来听吧..没有其它更多的意思 
 
 
    如果我们把大自然看成是一位伟大的程序员,专门为地球上的生态系统编制基因代码,并创造出各种不同的生物来,那么6500万年前的程序员开发的代码,是否兼容现代派的程序员的代码和架构呢? 
 
  
    
                                
    • 
                                
  • oracle 外部表
                                    daizj
oracle外部表external tables
                                    
        oracle外部表是只允许只读访问，不能进行DML操作，不能创建索引，可以对外部表进行的查询，连接，排序，创建视图和创建同义词操作。 
you can select, join, or sort external table data. You can also create views and synonyms for external tables. Ho
    
                                
    • 
                                
  • aop相关的概念及配置
                                    daysinsun
AOP
                                    
    切面(Aspect): 
通常在目标方法执行前后需要执行的方法（如事务、日志、权限），这些方法我们封装到一个类里面，这个类就叫切面。 
 
 
连接点（joinpoint） 
spring里面的连接点指需要切入的方法，通常这个joinpoint可以作为一个参数传入到切面的方法里面（非常有用的一个东西）。 
 
 
通知（Advice） 
通知就是切面里面方法的具体实现，分为前置、后置、最终、异常环
    
                                
    • 
                                
  • 初一上学期难记忆单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    middle 中间的，中级的 
well 喔，那么；好吧 
phone 电话，电话机 
policeman 警察 
ask 问 
take 拿到；带到 
address 地址 
glad 高兴的，乐意的 
why 为什么  
China 中国 
family 家庭 
grandmother (外)祖母 
grandfather (外)祖父 
wife 妻子 
husband 丈夫 
da
    
                                
    • 
                                
  • Linux日志分析常用命令
                                    dcj3sjt126com
linuxlog
                                    
    1.查看文件内容 
cat 
-n 显示行号 2.分页显示 
more 
Enter 显示下一行 
空格 显示下一页 
F 显示下一屏 
B 显示上一屏 
less 
/get 查询"get"字符串并高亮显示 3.显示文件尾 
tail 
-f 不退出持续显示 
-n 显示文件最后n行 4.显示头文件 
head 
-n 显示文件开始n行 5.内容排序 
sort 
-n 按照
    
                                
    • 
                                
  • JSONP 原理分析
                                    fantasy2005
JavaScriptjsonpjsonp 跨域
                                    
    转自 http://www.nowamagic.net/librarys/veda/detail/224 
JavaScript是一种在Web开发中经常使用的前端动态脚本技术。在JavaScript中，有一个很重要的安全性限制，被称为“Same-Origin Policy”（同源策略）。这一策略对于JavaScript代码能够访问的页面内容做了很重要的限制，即JavaScript只能访问与包含它的
    
                                
    • 
                                
  • 使用connect by进行级联查询
                                    234390216
oracle查询父子Connect by级联
                                    
    使用connect by进行级联查询 
  
       connect by可以用于级联查询，常用于对具有树状结构的记录查询某一节点的所有子孙节点或所有祖辈节点。 
  
       来看一个示例，现假设我们拥有一个菜单表t_menu，其中只有三个字段：
    
                                
    • 
                                
  • 一个不错的能将HTML表格导出为excel,pdf等的jquery插件
                                    jackyrong
jquery插件
                                    
    发现一个老外写的不错的jquery插件，可以实现将HTML 
表格导出为excel,pdf等格式， 
地址在： 
https://github.com/kayalshri/ 
 
下面看个例子，实现导出表格到excel,pdf 
 
 


<html>
			<head>
				<title>Export html table to excel an
    
                                
    • 
                                
  • UI设计中我们为什么需要设计动效
                                    lampcy
UIUI设计
                                    
    关于Unity3D中的Shader的知识 
首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，
    
                                
    • 
                                
  • 如何禁止页面缓存
                                    nannan408
htmljspcache
                                    
    禁止页面使用缓存~ 
------------------------------------------------ 
jsp:页面no cache： 
 
response.setHeader("Pragma","No-cache"); 
response.setHeader("Cache-Control","no-cach
    
                                
    • 
                                
  • 以代码的方式管理quartz定时任务的暂停、重启、删除、添加等
                                    Everyday都不同
定时任务管理spring-quartz
                                    
          【前言】在项目的管理功能中，对定时任务的管理有时会很常见。因为我们不能指望只在配置文件中配置好定时任务就行了，因为如果要控制定时任务的 “暂停” 呢？暂停之后又要在某个时间点 “重启” 该定时任务呢？或者说直接 “删除” 该定时任务呢？要改变某定时任务的触发时间呢？ “添加” 一个定时任务对于系统的使用者而言，是不太现实的，因为一个定时任务的处理逻辑他是不
    
                                
    • 
                                
  • EXT实例
                                    tntxia
ext
                                    
      
（1） 增加一个按钮 
  
JSP: 
  
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
Stri
    
                                
    • 
                                
  • 数学学习在计算机研究领域的作用和重要性
                                    xjnine
Math
                                    
    最近一直有师弟师妹和朋友问我数学和研究的关系，研一要去学什么数学课。毕竟在清华，衡量一个研究生最重要的指标之一就是paper,而没有数学，是肯定上不了世界顶级的期刊和会议的，这在计算机学界尤其重要！你会发现，不论哪个领域有价值的东西，都一定离不开数学！在这样一个信息时代，当google已经让世界没有秘密的时候，一种卓越的数学思维，绝对可以成为你的核心竞争力.  无奈本人实在见地
    
                                
    •