你的任务是使用java语言实现LR(0)活前缀DFA的构造，读取一个txt文件，文件的内容是一个普通的文法 ，识别并分析该文法（使用Grammar，Item等类），构造该文法的LR(0)活前缀DFA并输出，输出文件的内容是输入文法的活前缀DFA。给出具体代码,讲述代码思路,并给出示例。请注意，您提供的代码的代码必须可以正常运行并得出正确结果。

首先，我们需要定义一个文法类Grammar，表示一个文法。该类需要包含文法的终结符、非终结符、产生式等信息。我们还需要定义一个项目类Item，表示一个文法的项目。一个文法的项目由一个产生式和一个点组成，点表示该产生式中已经扫描过的符号。为了方便，我们可以使用字符串来表示产生式和点的位置。

接下来，我们需要实现一个LR(0)活前缀DFA的构造算法。该算法可以分为以下几个步骤：

1. 将文法的起始符号加入一个初始状态的项目集中。
2. 对于每个项目集，计算其闭包，即将该项目集中的每个项目的后继符号加入该项目集中。
3. 对于每个项目集和每个终结符，计算其GOTO集合，即该项目集中所有以该终结符为后继符号的项目组成的新项目集。
4. 重复步骤2和3，直到不再产生新的项目集为止。

最后，我们需要输出构造好的LR(0)活前缀DFA。可以将每个项目集和其对应的GOTO集合输出到文件中。

下面是具体的代码实现，其中的细节可以根据实际情况进行调整和优化。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;

public class LR0Parser {
    private Grammar grammar; // 文法
    private List<Set<Item>> itemSets; // 项目集
    private Map<Integer, Map<String, Integer>> gotoTable; // GOTO表
    private Map<Integer, Map<String, Action>> actionTable; // ACTION表

    public LR0Parser(String filename) throws IOException {
        grammar = readGrammar(filename);
        itemSets = new ArrayList<>();
        gotoTable = new HashMap<>();
        actionTable = new HashMap<>();
        buildLR0DFA();
        buildTables();
    }

    // 从文件中读取文法
    private Grammar readGrammar(String filename) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(filename));
        String line;
        List<String> productions = new ArrayList<>();
        while ((line = reader.readLine()) != null) {
            productions.add(line);
        }
        reader.close();
        return new Grammar(productions);
    }

    // 计算项目集的闭包
    private Set<Item> closure(Set<Item> items) {
        Set<Item> closure = new HashSet<>(items);
        boolean changed;
        do {
            changed = false;
            Set<Item> newItems = new HashSet<>();
            for (Item item : closure) {
                String symbol = item.getSymbolAfterDot();
                if (grammar.isNonTerminal(symbol)) {
                    for (String production : grammar.getProductions(symbol)) {
                        Item newItem = new Item(production, 0);
                        if (!closure.contains(newItem)) {
                            newItems.add(newItem);
                            changed = true;
                        }
                    }
                }
            }
            closure.addAll(newItems);
        } while (changed);
        return closure;
    }

    // 计算项目集的GOTO集合
    private Set<Item> gotoSet(Set<Item> items, String symbol) {
        Set<Item> gotoItems = new HashSet<>();
        for (Item item : items) {
            if (item.getSymbolAfterDot().equals(symbol)) {
                gotoItems.add(new Item(item.getProduction(), item.getDotPosition() + 1));
            }
        }
        return closure(gotoItems);
    }

    // 构造LR0DFA
    private void buildLR0DFA() {
        Set<Item> initialItems = closure(Collections.singleton(new Item(grammar.getStartSymbol() + "' -> " + grammar.getStartSymbol(), 0)));
        itemSets.add(initialItems);
        boolean changed;
        do {
            changed = false;
            for (int i = 0; i < itemSets.size(); i++) {
                Set<Item> items = itemSets.get(i);
                Map<String, Integer> gotoMap = new HashMap<>();
                for (Item item : items) {
                    String symbol = item.getSymbolAfterDot();
                    if (symbol != null && !gotoMap.containsKey(symbol)) {
                        Set<Item> gotoItems = gotoSet(items, symbol);
                        int gotoIndex = itemSets.indexOf(gotoItems);
                        if (gotoIndex == -1) {
                            itemSets.add(gotoItems);
                            gotoIndex = itemSets.size() - 1;
                            changed = true;
                        }
                        gotoMap.put(symbol, gotoIndex);
                    }
                }
                gotoTable.put(i, gotoMap);
            }
        } while (changed);
    }

    // 构造ACTION和GOTO表
    private void buildTables() {
        for (int i = 0; i < itemSets.size(); i++) {
            Map<String, Integer> gotoMap = gotoTable.get(i);
            Map<String, Action> actionMap = new HashMap<>();
            for (String symbol : grammar.getSymbols()) {
                if (grammar.isTerminal(symbol)) {
                    if (gotoMap.containsKey(symbol)) {
                        actionMap.put(symbol, new ShiftAction(gotoMap.get(symbol)));
                    }
                } else if (grammar.isEndSymbol(symbol)) {
                    if (grammar.getStartSymbol().equals(symbol)) {
                        actionMap.put(symbol, new AcceptAction());
                    } else {
                        for (Item item : itemSets.get(i)) {
                            if (item.isReduceItem()) {
                                if (item.getProduction().equals(symbol + " -> " + grammar.getEndSymbol())) {
                                    actionMap.put(symbol, new ReduceAction(item.getProduction()));
                                }
                            }
                        }
                    }
                } else {
                    if (gotoMap.containsKey(symbol)) {
                        actionMap.put(symbol, new GotoAction(gotoMap.get(symbol)));
                    }
                }
            }
            actionTable.put(i, actionMap);
        }
    }

    // 解析输入的句子
    public boolean parse(String sentence) {
        Stack<Integer> stateStack = new Stack<>();
        Stack<String> symbolStack = new Stack<>();
        stateStack.push(0);
        for (String symbol : sentence.split(" ")) {
            while (!actionTable.get(stateStack.peek()).containsKey(symbol)) {
                int state = stateStack.pop();
                String reduceSymbol = symbolStack.pop();
                Item reduceItem = new Item(reduceSymbol + " -> " + grammar.getEndSymbol(), 1);
                int reduceState = stateStack.peek();
                stateStack.push(actionTable.get(reduceState).get(reduceSymbol).getNextState());
                symbolStack.push(reduceSymbol);
            }
            Action action = actionTable.get(stateStack.peek()).get(symbol);
            action.execute(stateStack, symbolStack, grammar);
        }
        return stateStack.peek() == 1;
    }

    // 输出ACTION和GOTO表
    public void outputTables(String filename) throws IOException {
        FileWriter writer = new FileWriter(filename);
        writer.write("ACTION\n");
        for (int i = 0; i < itemSets.size(); i++) {
            Map<String, Action> actionMap = actionTable.get(i);
            writer.write("state " + i + "\n");
            for (String symbol : grammar.getSymbols()) {
                Action action = actionMap.get(symbol);
                if (action != null) {
                    writer.write(symbol + " " + action + "\n");
                }
            }
        }
        writer.write("\nGOTO\n");
        for (int i = 0; i < itemSets.size(); i++) {
            Map<String, Integer> gotoMap = gotoTable.get(i);
            writer.write("state " + i + "\n");
            for (String symbol : grammar.getSymbols()) {
                if (grammar.isNonTerminal(symbol)) {
                    Integer nextState = gotoMap.get(symbol);
                    if (nextState != null) {
                        writer.write(symbol + " " + nextState + "\n");
                    }
                }
            }
        }
        writer.close();
    }

    public static void main(String[] args) throws IOException {
        LR0Parser parser = new LR0Parser("grammar.txt");
        parser.outputTables("tables.txt");
        System.out.println(parser.parse("a * b + c"));
    }
}

// 文法类
class Grammar {
    private String startSymbol; // 起始符号
    private String endSymbol; // 结束符号
    private Set<String> terminals; // 终结符
    private Set<String> nonTerminals; // 非终结符
    private Map<String, List<String>> productions; // 产生式

    public Grammar(List<String> productions) {
        this.terminals = new HashSet<>();
        this.nonTerminals = new HashSet<>();
        this.productions = new HashMap<>();
        for (String production : productions) {
            String[] parts = production.split(" -> ");
            String left = parts[0];
            String right = parts[1];
            nonTerminals.add(left);
            for (String symbol : right.split(" ")) {
                if (!symbol.isEmpty()) {
                    if (symbol.equals("$")) {
                        endSymbol = left;
                    } else if (!Character.isUpperCase(symbol.charAt(0))) {
                        terminals.add(symbol);
                    }
                }
            }
            if (!this.productions.containsKey(left)) {
                this.productions.put(left, new ArrayList<>());
            }
            this.productions.get(left).add(right);
        }
        startSymbol = productions.get(0).split(" -> ")[0];
        nonTerminals.add(startSymbol + "'");
        productions.add(startSymbol + "' -> " + startSymbol);
    }

    public String getStartSymbol() {
        return startSymbol;
    }

    public String getEndSymbol() {
        return endSymbol;
    }

    public Set<String> getTerminals() {
        return terminals;
    }

    public Set<String> getNonTerminals() {
        return nonTerminals;
    }

    public Map<String, List<String>> getProductions() {
        return productions;
    }

    public List<String> getProductions(String symbol) {
        return productions.get(symbol);
    }

    public Set<String> getSymbols() {
        Set<String> symbols = new HashSet<>(terminals);
        symbols.addAll(nonTerminals);
        return symbols;
    }

    public boolean isTerminal(String symbol) {
        return terminals.contains(symbol);
    }

    public boolean isNonTerminal(String symbol) {
        return nonTerminals.contains(symbol);
    }

    public boolean isEndSymbol(String symbol) {
        return endSymbol.equals(symbol);
    }
}

// 项目类
class Item {
    private String production; // 产生式
    private int dotPosition; // 点的位置

    public Item(String production, int dotPosition) {
        this.production = production;
        this.dotPosition = dotPosition;
    }

    public String getProduction() {
        return production;
    }

    public int getDotPosition() {
        return dotPosition;
    }

    public String getSymbolAfterDot() {
        if (dotPosition < production.split(" ").length) {
            return production.split(" ")[dotPosition];
        } else {
            return null;
        }
    }

    public boolean isReduceItem() {
        return dotPosition == production.split(" ").length;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Item) {
            Item other = (Item) obj;
            return production.equals(other.production) && dotPosition == other.dotPosition;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return production.hashCode() + dotPosition;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        String[] symbols = production.split(" ");
        for (int i = 0; i < symbols.length; i++) {
            if (i == dotPosition) {
                builder.append(".");
            }
            builder.append(symbols[i]);
            builder.append(" ");
        }
        if (dotPosition == symbols.length) {
            builder.append(".");
        }
        return builder.toString().trim();
    }
}

// ACTION表中的动作类
abstract class Action {
    abstract int getNextState();
    abstract void execute(Stack<Integer> stateStack, Stack<String> symbolStack, Grammar grammar);
}

// ACTION表中的Shift动作类
class ShiftAction extends Action {
    private int nextState;

    public ShiftAction(int nextState) {
        this.nextState = nextState;
    }

    @Override
    int getNextState() {
        return nextState;
    }

    @Override
    void execute(Stack<Integer> stateStack, Stack<String> symbolStack, Grammar grammar) {
        stateStack.push(nextState);
        symbolStack.push(grammar.getTerminals().iterator().next());
    }

    @Override
    public String toString() {
        return "s" + nextState;
    }
}

// ACTION表中的Reduce动作类
class ReduceAction extends Action {
    private String production;

    public ReduceAction(String production) {
        this.production = production;
    }

    @Override
    int getNextState() {
        return -1;
    }

    @Override
    void execute(Stack<Integer> stateStack, Stack<String> symbolStack, Grammar grammar) {
        String left = production.split(" -> ")[0];
        int length = production.split(" -> ")[1].split(" ").length;
        for (int i = 0; i < length; i++) {
            stateStack.pop();
            symbolStack.pop();
        }
        symbolStack.push(left);
        stateStack.push(getNextState());
    }

    @Override
    public String toString() {
        return "r" + production;
    }
}

// ACTION表中的Accept动作类
class AcceptAction extends Action {
    @Override
    int getNextState() {
        return -1;
    }

    @Override
    void execute(Stack<Integer> stateStack, Stack<String> symbolStack, Grammar grammar) {

    }

    @Override
    public String toString() {
        return "acc";
    }
}

// GOTO表中的动作类
class GotoAction extends Action {
    private int nextState;

    public GotoAction(int nextState) {
        this.nextState = nextState;
    }

    @Override
    int getNextState() {
        return nextState;
    }

    @Override
    void execute(Stack<Integer> stateStack, Stack<String> symbolStack, Grammar grammar) {
        stateStack.push(nextState);
    }

    @Override
    public String toString() {
        return "" + nextState;
    }
}

示例文法文件grammar.txt内容如下：

E -> E + T
E -> E - T
E -> T
T -> T * F
T -> T / F
T -> F
F -> ( E )
F -> id

执行main函数后，程序将输出ACTION和GOTO表到文件tables.txt，并判断输入的句子是否符合该文法。