借助他人代码完成完成编译原理ll1语法分析器，同时修改了其中一些不妥的地方

感谢，原作者地址
http://blog.csdn.net/puhaiyang/article/details/51793550
主要修改了getFirst与getFollow和getselect这三个函数  

以下附上完整代码

TopDownSyntaxAnalyzer类
package task2;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* @author 沈廷威
* @email 526588851@qq.com
* @function 计算推导规则
* 在别人的基础上自己重写了first和follow集和select集的函数
*
*/
public class TopDownSyntaxAnalyzer implements Serializable {
public TopDownSyntaxAnalyzer() {
super();
gsArray = new ArrayList<String>();
nvSet = new TreeSet<Character>();
ntSet = new TreeSet<Character>();
firstMap = new HashMap<Character, TreeSet<Character>>();
followMap = new HashMap<Character, TreeSet<Character>>();
selectMap = new TreeMap<Character, HashMap<String, TreeSet<Character>>>();
}
private String[][] analyzeTable;

/**
* Select集合
*/
private TreeMap<Character, HashMap<String, TreeSet<Character>>> selectMap;
/**
* LL（1）文法产生集合
*/
private ArrayList<String> gsArray;
/**
* 表达式集合
*/
private HashMap<Character, ArrayList<String>> expressionMap;
/**
* 开始符
*/
private Character s;
/**
* Vn非终结符集合
*/
private TreeSet<Character> nvSet;
/**
* Vt终结符集合
*/
private TreeSet<Character> ntSet;
/**
* First集合
*/
private HashMap<Character, TreeSet<Character>> firstMap;
/**
* Follow集合
*/
private HashMap<Character, TreeSet<Character>> followMap;

public String[][] getAnalyzeTable() {
return analyzeTable;
}

public void setAnalyzeTable(String[][] analyzeTable) {
this.analyzeTable = analyzeTable;
}

public TreeMap<Character, HashMap<String, TreeSet<Character>>> getSelectMap() {
return selectMap;
}

public void setSelectMap(TreeMap<Character, HashMap<String, TreeSet<Character>>> selectMap) {
this.selectMap = selectMap;
}

public ArrayList<String> getGsArray() {
return gsArray;
}

public void setGsArray(ArrayList<String> gsArray) {
this.gsArray = gsArray;
}

public HashMap<Character, ArrayList<String>> getExpressionMap() {
return expressionMap;
}

public void setExpressionMap(HashMap<Character, ArrayList<String>> expressionMap) {
this.expressionMap = expressionMap;
}

public Character getS() {
return s;
}

public void setS(Character s) {
this.s = s;
}

public TreeSet<Character> getNvSet() {
return nvSet;
}

public void setNvSet(TreeSet<Character> nvSet) {
this.nvSet = nvSet;
}

public TreeSet<Character> getNtSet() {
return ntSet;
}

public void setNtSet(TreeSet<Character> ntSet) {
this.ntSet = ntSet;
}

public HashMap<Character, TreeSet<Character>> getFirstMap() {
return firstMap;
}

public void setFirstMap(HashMap<Character, TreeSet<Character>> firstMap) {
this.firstMap = firstMap;
}

public HashMap<Character, TreeSet<Character>> getFollowMap() {
return followMap;
}

public void setFollowMap(HashMap<Character, TreeSet<Character>> followMap) {
this.followMap = followMap;
}
public void getNvNt() {
for (String gsItem : gsArray) {
String[] nvNtItem = gsItem.split("->");
String charItemStr = nvNtItem[0];
char charItem = charItemStr.charAt(0);
// nv在左边
nvSet.add(charItem);
}
for (String gsItem : gsArray) {
String[] nvNtItem = gsItem.split("->");
// nt在右边
String nvItemStr = nvNtItem[1];
// 遍历每一个字
for (int i = 0; i < nvItemStr.length(); i++) {
char charItem = nvItemStr.charAt(i);
if (!nvSet.contains(charItem)) {
ntSet.add(charItem);
}
}
}
}

/**
* 初始化表达式集合
*/
public void initExpressionMaps() {
expressionMap = new HashMap<Character, ArrayList<String>>();
for (String gsItem : gsArray) {
String[] nvNtItem = gsItem.split("->");
String charItemStr = nvNtItem[0];
String charItemRightStr = nvNtItem[1];
if(charItemRightStr.length()>1&&charItemRightStr.indexOf('ε')>=0){
charItemRightStr=charItemRightStr.replace("ε", "");
}
char charItem = charItemStr.charAt(0);
if (!expressionMap.containsKey(charItem)) {
ArrayList<String> expArr = new ArrayList<String>();
expArr.add(charItemRightStr);
expressionMap.put(charItem, expArr);
} else {
ArrayList<String> expArr = expressionMap.get(charItem);
expArr.add(charItemRightStr);
expressionMap.put(charItem, expArr);
}
}
}

/**
* 获取First集
*/
// public void getFirst() {
// // 遍历所有Nv,求出它们的First集合
// Iterator<Character> iterator = nvSet.iterator();
// while (iterator.hasNext()) {
// Character charItem = iterator.next();
// ArrayList<String> arrayList = expressionMap.get(charItem);
// for (String itemStr : arrayList) {
// boolean shouldBreak = false;
// // Y1Y2Y3...Yk
// for (int i = 0; i < itemStr.length(); i++) {
// char itemitemChar = itemStr.charAt(i);
// TreeSet<Character> itemSet = firstMap.get(charItem);
// if (null == itemSet) {
// itemSet = new TreeSet<Character>();
// }
// shouldBreak = calcFirst(itemSet, charItem, itemitemChar);
// if (shouldBreak) {
// break;
// }
// }
// }
// }
// }
public TreeSet<Character> getFirst(char charItem){
ArrayList<String> arrayList = expressionMap.get(charItem);
TreeSet<Character> itemSet = firstMap.get(charItem);
if (null != itemSet) {
return itemSet;

}
else{
itemSet = new TreeSet<Character>();
}
for (String itemStr : arrayList) {
for (int i = 0; i < itemStr.length(); i++) {
char itemitemChar = itemStr.charAt(i);
if (itemitemChar != 'ε' && ntSet.contains(itemitemChar)){
itemSet.add(itemitemChar);
break;
}
else{
if(i==itemStr.length()-1&&itemitemChar == 'ε'){
itemSet.add('ε');
}else{
if(itemitemChar != 'ε'){
TreeSet<Character> tempfirst=getFirst(itemitemChar);
Iterator<Character> iterator = tempfirst.iterator();
while(iterator.hasNext()){
Character tempfirstcharitem = iterator.next();
if(tempfirstcharitem!='ε'){
itemSet.add(tempfirstcharitem);
}
}
if(!tempfirst.contains('ε')){
break;
}
else{
if(i==itemStr.length()-1){
itemSet.add('ε');
}
}
}
}
}
}
}
firstMap.put(charItem, itemSet);
return itemSet;
}
public TreeSet<Character> getFollow(char charItem){
TreeSet<Character> itemSet = followMap.get(charItem);
if (null != itemSet) {
return itemSet;

}
else{
itemSet = new TreeSet<Character>();
}
if(charItem=='E'){
itemSet.add('#');
}
Iterator<Character> iterator = nvSet.iterator();
while (iterator.hasNext()) {
Character charItem1 = iterator.next();
ArrayList<String> arrayList = expressionMap.get(charItem1);
for (String itemStr : arrayList) {
int positionofcharitem=itemStr.indexOf(charItem);
if(positionofcharitem>=0){
if(positionofcharitem==itemStr.length()-1){
if(charItem1!=charItem){
TreeSet<Character> tempfollow=getFollow(charItem1);
Iterator<Character> iterator1 = tempfollow.iterator();
while(iterator1.hasNext()){
Character tempfollowcharitem = iterator1.next();
itemSet.add(tempfollowcharitem);
}
}
}
else{
// if(nvSet.contains(
e15d
itemStr.charAt(positionofcharitem+1))){
int tempposition=positionofcharitem+1;

boolean con=false;
for(int i=tempposition;i<itemStr.length();i++){
if(nvSet.contains(itemStr.charAt(i))){
TreeSet<Character> tempfirst=getFirst(itemStr.charAt(i));
Iterator<Character> iterator1 = tempfirst.iterator();
while(iterator1.hasNext()){
Character tempfirstcharitem = iterator1.next();
if(tempfirstcharitem!='ε'){
itemSet.add(tempfirstcharitem);
}else{
con=true;
}
}
}
else{
if(itemStr.charAt(i)!='ε'){
itemSet.add(itemStr.charAt(i));
con=false;
}
else{
con=true;
}
}
if(con){
if(i==itemStr.length()-1){
if(charItem1!=charItem){
TreeSet<Character> tempfollow=getFollow(charItem1);
Iterator<Character> iterator2 = tempfollow.iterator();
while(iterator2.hasNext()){
Character tempfollowcharitem = iterator2.next();
itemSet.add(tempfollowcharitem);
}
}
}else{
continue;
}
}else{
break;
}
}

}

}
}
}
followMap.put(charItem, itemSet);
return itemSet;
}

public void getSelect() {
// 遍历每一个表达式
// HashMap<Character, HashMap<String, TreeSet<Character>>>
Set<Character> keySet = expressionMap.keySet();
for (Character selectKey : keySet) {
ArrayList<String> arrayList = expressionMap.get(selectKey);
// 每一个表达式
HashMap<String, TreeSet<Character>> selectItemMap = new HashMap<String, TreeSet<Character>>();
for (String selectExp : arrayList) {
/**
* 存放select结果的集合
*/

TreeSet<Character> selectSet = new TreeSet<Character>();
// set里存放的数据分3种情况,由selectExp决定
// 1.A->ε,=follow(A)
if (TextUtil.isEmptyStart(selectExp,firstMap)) {

selectSet = followMap.get(selectKey);
selectSet.remove('ε');
selectItemMap.put(selectExp, selectSet);
}
// 2.Nt开始,=Nt
// <br>终结符开始
if (TextUtil.isNtStart(ntSet, selectExp)) {
selectSet.add(selectExp.charAt(0));
selectSet.remove('ε');
selectItemMap.put(selectExp, selectSet);
}
// 3.Nv开始，=first(Nv)
if (TextUtil.isNvStart(nvSet, selectExp)) {
for(int i=0;i<selectExp.length();i++){
if(selectExp.charAt(i)=='ε'){
continue;
}
else{
TreeSet<Character> tempset=firstMap.get(selectExp.charAt(i));
if(tempset==null){
selectSet.add(selectExp.charAt(i));
selectSet.remove('ε');
selectItemMap.put(selectExp, selectSet);
break;
}
else{
selectSet = tempset;
selectSet.remove('ε');
selectItemMap.put(selectExp, selectSet);
if(tempset.contains('ε')){
continue;
}
else{
break;
}
}
}
}
}
selectMap.put(selectKey, selectItemMap);
}
}
}

public void genAnalyzeTable() throws Exception {
Object[] ntArray = ntSet.toArray();
Object[] nvArray = nvSet.toArray();
// 预测分析表初始化
analyzeTable = new String[nvArray.length + 1][ntArray.length + 1];

// 输出一个占位符
System.out.print("Nv/Nt" + "\t\t");
analyzeTable[0][0] = "Nv/Nt";
// 初始化首行
for (int i = 0; i < ntArray.length; i++) {
if (ntArray[i].equals('ε')) {
ntArray[i] = '#';
}
System.out.print(ntArray[i] + "\t\t");
analyzeTable[0][i + 1] = ntArray[i] + "";
}

System.out.println("");
for (int i = 0; i < nvArray.length; i++) {
// 首列初始化
System.out.print(nvArray[i] + "\t\t");
analyzeTable[i + 1][0] = nvArray[i] + "";
for (int j = 0; j < ntArray.length; j++) {
String findUseExp = TextUtil.findUseExp(selectMap, Character.valueOf((Character) nvArray[i]),
Character.valueOf((Character) ntArray[j]));
if (null == findUseExp) {
System.out.print("\t\t");
analyzeTable[i + 1][j + 1] = "";
} else {
System.out.print(nvArray[i] + "->" + findUseExp + "\t\t");
analyzeTable[i + 1][j + 1] = nvArray[i] + "->" + findUseExp;
}
}
System.out.println();
}
}

public static void main(String[] args) {
// TODO Auto-generated method stub
//test first集是否正常生成
ArrayList<String> test=new ArrayList<String>();
test.add("E->TR");
test.add("R->+TR");
test.add("R->ε");
test.add("T->FZ");
test.add("Z->*FZε");
test.add("Z->ε");
test.add("F->i");
test.add("F->(E)");
TopDownSyntaxAnalyzer tester=new TopDownSyntaxAnalyzer();
tester.setGsArray(test);
tester.getNvNt();
tester.initExpressionMaps();

Iterator<Character> iterator =tester.getNvSet().iterator();
while (iterator.hasNext()) {
Character charItem = iterator.next();
tester.getFirst(charItem);
}
Iterator<Character> iterator1 =tester.getNvSet().iterator();
while (iterator1.hasNext()) {
Character charItem = iterator1.next();
tester.getFollow(charItem);
}
// System.out.println("终结符集合"+tester.getNtSet());
tester.getSelect();
System.out.println("first集"+tester.getFirstMap());
System.out.println("follow集"+tester.getFollowMap());
//System.out.println(tester.getSelectMap());
System.out.println("递推表：");

try {
tester.genAnalyzeTable();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("推导过程：");
Analyzer analyzer = new Analyzer();
analyzer.setStartChar('E');
analyzer.setLl1Gs(tester);
analyzer.setStr("i+i*i#");
analyzer.analyze();

System.out.println("");

}

}


TextUtil类package task2;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

/**
* @author PuHaiyang &&沈廷威
* @createTime 2018.01.01
* @email 761396462@qq.com &&526588851@qq.com
* @function 字符工具类
* 修改了和生成select集相关的几个判断条件
*
*/
public class TextUtil {
/**
* (3)B->aA,=Follow(B)
*
* @param nvSet
* @param itemCharStr
* @param a
* @param expressionMap
* @return
*/
public static boolean containsbA(TreeSet<Character> nvSet, String itemCharStr, Character a,
HashMap<Character, ArrayList<String>> expressionMap) {
String aStr = a.toString();
String lastStr = itemCharStr.substring(itemCharStr.length() - 1);
if (lastStr.equals(aStr)) {
return true;
}
return false;

}

/**
* 形如aBb,b=空
*
* @param nvSet
* @param itemCharStr
* @param a
* @param expressionMap
* @return
*/
public static boolean containsbAbIsNull(TreeSet<Character> nvSet, String itemCharStr, Character a,
HashMap<Character, ArrayList<String>> expressionMap) {
String aStr = a.toString();
if (containsAB(nvSet, itemCharStr, a)) {
Character alastChar = getAlastChar(itemCharStr, a);
System.out.println("----------------+++++++++++++++++++--" + expressionMap.toString());
ArrayList<String> arrayList = expressionMap.get(alastChar);
if (arrayList.contains("ε")) {
System.out.println(alastChar + " contains('ε')" + aStr);
return true;
}
}
return false;

}

/**
* 是否包含这种的字符串<Br>
* (2)Ab,=First(b)-ε,直接添加终结符
*
* @param str
* @param a
* @return
*/
public static boolean containsAb(TreeSet<Character> ntSet, String itemCharStr, Character a) {
String aStr = a.toString();
if (itemCharStr.contains(aStr)) {
int aIndex = itemCharStr.indexOf(aStr);
String findStr;
try {
findStr = itemCharStr.substring(aIndex + 1, aIndex + 2);
} catch (Exception e) {
return false;
}
if (ntSet.contains(findStr.charAt(0))) {
return true;
} else {
return false;
}
} else {
return false;
}
}

/**
* 是否包含这种的字符串<Br>
* (2).2Ab,=First(b)-ε
*
* @param str
* @param a
* @return
*/
public static boolean containsAB(TreeSet<Character> nvSet, String itemCharStr, Character a) {
String aStr = a.toString();
if (itemCharStr.contains(aStr)) {
int aIndex = itemCharStr.indexOf(aStr);
String findStr;
try {
findStr = itemCharStr.substring(aIndex + 1, aIndex + 2);
} catch (Exception e) {
return false;
}
if (nvSet.contains(findStr.charAt(0))) {
return true;
} else {
return false;
}
} else {
return false;
}
}

/**
* 获取A后的字符
*
* @param itemCharStr
* @param a
* @return
*/
public static Character getAlastChar(String itemCharStr, Character a) {
String aStr = a.toString();
if (itemCharStr.contains(aStr)) {
int aIndex = itemCharStr.indexOf(aStr);
String findStr = "";
try {
findStr = itemCharStr.substring(aIndex + 1, aIndex + 2);
} catch (Exception e) {
return null;
}
return findStr.charAt(0);
}
return null;
}

/**
* 是否为ε开始的
*
* @param selectExp
* @return
*/
public static boolean isEmptyStart(String selectExp, HashMap<Character, TreeSet<Character>> firstMap) {
for(int i=0;i<selectExp.length();i++){
if(selectExp.charAt(i)=='ε'){
continue;
}
else{
TreeSet<Character> tempset=firstMap.get(selectExp.charAt(i));
if(tempset==null){
return false;
}
else{
if(tempset.contains('ε')){
continue;
}
else{
return false;
}
}
}
}
return true;
}

/**
* 是否是终结符开始的
*
* @param ntSet
* @param selectExp
* @return
*/
public static boolean isNtStart(TreeSet<Character> ntSet, String selectExp) {
char charAt = selectExp.charAt(0);
if (ntSet.contains(charAt)&&charAt!='ε') {
return true;
}
return false;
}

/**
* 是否是非终结符开始的
*
* @param nvSet
* @param selectExp
* @return
*/
public static boolean isNvStart(TreeSet<Character> nvSet, String selectExp) {
char charAt = selectExp.charAt(0);
if (nvSet.contains(charAt)) {
return true;
}
return false;
}

/**
* 查找产生式
*
* @param selectMap
* @param peek
* 当前Nv
* @param charAt
* 当前字符
* @return
*/
public static String findUseExp(TreeMap<Character, HashMap<String, TreeSet<Character>>> selectMap, Character peek,
char charAt) {
try {
HashMap<String, TreeSet<Character>> hashMap = selectMap.get(peek);
Set<String> keySet = hashMap.keySet();
for (String useExp : keySet) {
TreeSet<Character> treeSet = hashMap.get(useExp);
if (treeSet.contains(charAt)) {
return useExp;
}
}
} catch (Exception e) {
return null;
}
return null;
}
}


Analyzer类

package task2;
import java.util.ArrayList;
import java.util.Stack;
/**
* @author PuHaiyang
* @createTime 2016年6月11日 下午11:27:00
* @email 761396462@qq.com
* @function 句子分析器
*
*/
public class Analyzer {

public Analyzer() {
super();
analyzeStatck = new Stack<Character>();
// 结束符进栈
analyzeStatck.push('#');
}

private ArrayList<AnalyzeProduce> analyzeProduces;

/**
* LL（1）文法
*/
private TopDownSyntaxAnalyzer ll1Gs;

public TopDownSyntaxAnalyzer getLl1Gs() {
return ll1Gs;
}

public void setLl1Gs(TopDownSyntaxAnalyzer ll1Gs) {
this.ll1Gs = ll1Gs;
}

/**
* 开始符
*/
private Character startChar;

/**
* 分析栈
*/
private Stack<Character> analyzeStatck;
/**
* 剩余输入串
*/
private String str;
/**
* 推导所用产生或匹配
*/
private String useExp;

public ArrayList<AnalyzeProduce> getAnalyzeProduces() {
return analyzeProduces;
}

public void setAnalyzeProduces(ArrayList<AnalyzeProduce> analyzeProduces) {
this.analyzeProduces = analyzeProduces;
}

public Character getStartChar() {
return startChar;
}

public void setStartChar(Character startChar) {
this.startChar = startChar;
}

public Stack<Character> getAnalyzeStatck() {
return analyzeStatck;
}

public void setAnalyzeStatck(Stack<Character> analyzeStatck) {
this.analyzeStatck = analyzeStatck;
}

public String getStr() {
return str;
}

public void setStr(String str) {
this.str = str;
}

public String getUseExp() {
return useExp;
}

public void setUseExp(String useExp) {
this.useExp = useExp;
}

/**
* 分析
*/
public void analyze() {
analyzeProduces = new ArrayList<AnalyzeProduce>();

// 开始符进栈
analyzeStatck.push(startChar);
System.out.println("开始符:" + startChar);
int index = 0;
// 开始分析
// while (analyzeStatck.peek() != '#' && str.charAt(0) != '#') {
while (!analyzeStatck.empty()) {
index++;
if (analyzeStatck.peek() != str.charAt(0)) {
// 到分析表中找到这个产生式
String nowUseExpStr = TextUtil.findUseExp(ll1Gs.getSelectMap(), analyzeStatck.peek(), str.charAt(0));
System.out.println(index + "\t\t\t" + analyzeStatck.toString() + "\t\t\t" + str + "\t\t\t"
+ analyzeStatck.peek() + "->" + nowUseExpStr);
AnalyzeProduce produce = new AnalyzeProduce();
produce.setIndex(index);
produce.setAnalyzeStackStr(analyzeStatck.toString());
produce.setStr(str);
if (null == nowUseExpStr) {
produce.setUseExpStr("无法匹配!");
} else {
produce.setUseExpStr(analyzeStatck.peek() + "->" + nowUseExpStr);
}
analyzeProduces.add(produce);
// 将之前的分析栈中的栈顶出栈
analyzeStatck.pop();
// 将要用到的表达式入栈,反序入栈
if (null != nowUseExpStr && nowUseExpStr.charAt(0) != 'ε') {
for (int j = nowUseExpStr.length() - 1; j >= 0; j--) {
char currentChar = nowUseExpStr.charAt(j);
analyzeStatck.push(currentChar);
}
}
continue;
}
// 如果可以匹配,分析栈出栈，串去掉一位
if (analyzeStatck.peek() == str.charAt(0)) {
System.out.println(index + "\t\t\t" + analyzeStatck.toString() + "\t\t\t" + str + "\t\t\t" + "“"
+ str.charAt(0) + "”匹配");
AnalyzeProduce produce = new AnalyzeProduce();
produce.setIndex(index);
produce.setAnalyzeStackStr(analyzeStatck.toString());
produce.setStr(str);
produce.setUseExpStr("“" + str.charAt(0) + "”匹配");
analyzeProduces.add(produce);
analyzeStatck.pop();
str = str.substring(1);
continue;
}
}

}

}


AnalyzeProduce类

package task2;

import java.io.Serializable;

/**
* @author PuHaiyang
* @createTime 2016年6月12日 下午4:15:37
* @email 761396462@qq.com
* @function 分析过程Bean
*
*/
public class AnalyzeProduce implements Serializable{
private static final long serialVersionUID = 10L;
private Integer index;
private String analyzeStackStr;
private String str;
private String useExpStr;

public Integer getIndex() {
return index;
}

public void setIndex(Integer index) {
this.index = index;
}

public String getAnalyzeStackStr() {
return analyzeStackStr;
}

public void setAnalyzeStackStr(String analyzeStackStr) {
this.analyzeStackStr = analyzeStackStr;
}

public String getStr() {
return str;
}

public void setStr(String str) {
this.str = str;
}

public String getUseExpStr() {
return useExpStr;
}

public void setUseExpStr(String useExpStr) {
this.useExpStr = useExpStr;
}

}