import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;

public class CalcTest {
    public static void main(String[] args) throws Exception {
        CalcLexer lexer = new CalcLexer(CharStreams.fromString("1 + 2 * (3 + 4) - 5 / 6"));
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        CalcParser parser = new CalcParser(tokens);
        ParseTree tree = parser.calc();
        System.out.println(tree.toStringTree(parser));
    }
}

package com.nosuchfield.calc;

import com.nosuchfield.calc.code.CalcBaseVisitor;
import com.nosuchfield.calc.code.CalcLexer;
import com.nosuchfield.calc.code.CalcParser;
import org.antlr.v4.runtime.Token;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.Objects;

public class CalculateVisitor extends CalcBaseVisitor<BigDecimal> {

    /**
     * 用于设置BigDecimal的计算精度
     */
    private static final MathContext MATH_CONTEXT = MathContext.DECIMAL128;

    /**
     * calc语法，包含了多个expr，返回最后一个expr的结果
     */
    @Override
    public BigDecimal visitCalculationBlock(CalcParser.CalculationBlockContext ctx) {
        BigDecimal calcResult = null;
        for (CalcParser.ExprContext expr : ctx.expr()) {
            calcResult = visit(expr);
        }
        return calcResult;
    }

    /**
     * 左右括号，取出括号中的表达式
     */
    @Override
    public BigDecimal visitExpressionWithBr(CalcParser.ExpressionWithBrContext ctx) {
        return visit(ctx.expr());
    }

    /**
     * 乘除法，返回左右两个元素的计算结果
     * 其中op属性是在语法文件中自定义的
     */
    @Override
    public BigDecimal visitExpressionMulOrDiv(CalcParser.ExpressionMulOrDivContext ctx) {
        BigDecimal left = visit(ctx.expr(0));
        BigDecimal right = visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case CalcParser.MUL:
                return left.multiply(right, MATH_CONTEXT);
            case CalcParser.DIV:
                return left.divide(right, MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported operator type");
        }
    }

    /**
     * 加减法，返回左右两个元素的计算结果
     * 其中op属性是在语法文件中自定义的
     */
    @Override
    public BigDecimal visitExpressionAddOrSub(CalcParser.ExpressionAddOrSubContext ctx) {
        BigDecimal left = visit(ctx.expr(0));
        BigDecimal right = visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case CalcParser.ADD:
                return left.add(right, MATH_CONTEXT);
            case CalcParser.SUB:
                return left.subtract(right, MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported operator type");
        }
    }

    /**
     * 获取数值，num属性是在语法文件中定义的
     * 如果数值前有负号就取负值
     */
    @Override
    public BigDecimal visitExpressionNumeric(CalcParser.ExpressionNumericContext ctx) {
        BigDecimal numeric = numberOrPercent(ctx.num);
        if (Objects.nonNull(ctx.sign) && ctx.sign.getType() == CalcLexer.SUB) {
            return numeric.negate();
        }
        return numeric;
    }

    /**
     * 将文本内容转化为BigDecimal，包含数字和百分数
     */
    private BigDecimal numberOrPercent(Token num) {
        String numberStr = num.getText();
        switch (num.getType()) {
            case CalcLexer.NUMBER:
                return new BigDecimal(numberStr);
            case CalcLexer.PERCENT_NUMBER:
                return new BigDecimal(numberStr.substring(0, numberStr.length() - 1).trim())
                        .divide(BigDecimal.valueOf(100), MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported number type");
        }
    }

}

package com.nosuchfield.calc;

import com.nosuchfield.calc.code.CalcLexer;
import com.nosuchfield.calc.code.CalcParser;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.junit.Test;

import java.math.BigDecimal;

import static junit.framework.TestCase.assertEquals;

public class TestCalculate {

    @Test
    public void testCalculate() {
        String[][] sources = new String[][]{
                {"1 + 2", "3"},
                {"3 - 2", "1"},
                {"2 * 3", "6"},
                {"6 / 3", "2"},
                {"6 / (1 + 2)", "2"},
                {"50%", "0.5"},
                {"100 * 30%", "30.0"},
                {"1 + 2 * (3 - 4) / 5", "0.6"},
                {"-8 + 8 * 2 - 8", "0"}
        };
        for (String[] source : sources) {
            String input = source[0].trim();
            BigDecimal result = new BigDecimal(source[1].trim());
            assertEquals(calculate(input), result);
        }
    }

    /**
     * 计算表达式
     *
     * @param expression 表达式
     * @return 计算的结果
     */
    private BigDecimal calculate(String expression) {
        CharStream cs = CharStreams.fromString(expression);
        CalcLexer lexer = new CalcLexer(cs);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        CalcParser parser = new CalcParser(tokens);
        CalcParser.CalcContext context = parser.calc();
        CalculateVisitor visitor = new CalculateVisitor();
        return visitor.visit(context);
    }

}

package com.nosuchfield.csv;

import com.nosuchfield.csv.code.CsvBaseListener;
import com.nosuchfield.csv.code.CsvParser;

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

public class CsvListener extends CsvBaseListener {

    /**
     * CSV的多行数据
     */
    private final List<Map<String, String>> rows = new ArrayList<>();

    /**
     * CSV的头部
     */
    private List<String> header;

    /**
     * 一行CSV数据
     */
    private List<String> row;

    /**
     * 进入一行
     */
    @Override
    public void enterRow(CsvParser.RowContext ctx) {
        // 创建一个list用来保存这一行的数据
        row = new ArrayList<>();
    }

    /**
     * 离开TEXT
     */
    @Override
    public void exitText(CsvParser.TextContext ctx) {
        // 添加这一列的数据
        row.add(ctx.TEXT().getText());
    }

    @Override
    public void exitString(CsvParser.StringContext ctx) {
        // 获取字符
        String field = ctx.STRING().getText();
        // 移除头部和尾部的双引号
        field = field.substring(1, field.length() - 2);
        // 因为CSV在双引号中用两个双引号代表单引号，这里转回来
        field = field.replaceAll("\"\"", "\"");
        row.add(field);
    }

    @Override
    public void exitEmpty(CsvParser.EmptyContext ctx) {
        // 添加空字符串
        row.add("");
    }

    /**
     * 离开某一行
     */
    @Override
    public void exitRow(CsvParser.RowContext ctx) {
        if (ctx.getParent() instanceof CsvParser.HdrContext) {
            // 如果某一行的父节点是header头部
            // 那么就把header的值设置成这一行的数据
            header = row;
            return;
        }
        Map<String, String> data = new HashMap<>();
        // 某一行已经遍历完毕，将这一行的数据和header组合起来，构成一个map
        for (int i = 0; i < row.size(); i++) {
            data.put(header.get(i), row.get(i));
        }
        // 将这一行数据添加到数据集中
        rows.add(data);
    }

    public List<Map<String, String>> getRows() {
        return rows;
    }

}

public void testCsv() throws IOException {
    // 从文件中取得CSV数据流，并生成lexer
    CsvLexer lexer = new CsvLexer(CharStreams.fromFileName("src/main/resources/csv/city.csv"));
    // 根据lexer生成token
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    // 将token交给parser
    CsvParser parser = new CsvParser(tokens);
    // 生成语法树
    ParseTree tree = parser.csv();
    // 打印语法树
    System.out.println(tree.toStringTree(parser));

    // 构建语法树遍历器
    ParseTreeWalker parseTreeWalker = new ParseTreeWalker();
    // 语法树监听器
    CsvListener listener = new CsvListener();
    // 遍历语法树
    parseTreeWalker.walk(listener, tree);
    // 打印生成的结果
    System.out.println(listener.getRows());
}

public class CalculateListener extends CalcBaseListener {

    private static final MathContext MATH_CONTEXT = MathContext.DECIMAL128;

    private Stack<BigDecimal> stack;

    private BigDecimal result;

    @Override
    public void enterCalculationBlock(CalcParser.CalculationBlockContext ctx) {
        // 创建新的栈
        stack = new Stack<>();
    }

    @Override
    public void exitCalculationBlock(CalcParser.CalculationBlockContext ctx) {
        // 取出栈顶元素作为结果
        result = stack.pop();
    }

    @Override
    public void exitExpressionMulOrDiv(CalcParser.ExpressionMulOrDivContext ctx) {
        // 将栈顶的两个元素取出来做乘除法，将结果压回栈
        BigDecimal x = stack.pop();
        BigDecimal y = stack.pop();
        BigDecimal z;
        switch (ctx.op.getType()) {
            case CalcLexer.MUL:
                z = y.multiply(x, MATH_CONTEXT);
                break;
            case CalcLexer.DIV:
                z = y.divide(x, MATH_CONTEXT);
                break;
            default:
                throw new RuntimeException("unsupported operator type");
        }
        stack.push(z);
    }

    @Override
    public void exitExpressionAddOrSub(CalcParser.ExpressionAddOrSubContext ctx) {
        // 将栈顶两个元素取出来做加减法，将结果压回栈
        BigDecimal x = stack.pop();
        BigDecimal y = stack.pop();
        BigDecimal z;
        switch (ctx.op.getType()) {
            case CalcLexer.ADD:
                z = y.add(x, MATH_CONTEXT);
                break;
            case CalcLexer.SUB:
                z = y.subtract(x, MATH_CONTEXT);
                break;
            default:
                throw new RuntimeException("unsupported operator type");
        }
        stack.push(z);
    }

    @Override
    public void exitExpressionNumeric(CalcParser.ExpressionNumericContext ctx) {
        // 计算数字
        BigDecimal numeric = numberOrPercent(ctx.num);
        if (Objects.nonNull(ctx.sign) && ctx.sign.getType() == CalcLexer.SUB) {
            numeric = numeric.negate();
        }
        stack.push(numeric);
    }

    private BigDecimal numberOrPercent(Token num) {
        String numberStr = num.getText();
        switch (num.getType()) {
            case CalcLexer.NUMBER:
                return new BigDecimal(numberStr);
            case CalcLexer.PERCENT_NUMBER:
                return new BigDecimal(numberStr.substring(0, numberStr.length() - 1).trim())
                        .divide(BigDecimal.valueOf(100), MATH_CONTEXT);
            default:
                throw new RuntimeException("unsupported number type");
        }
    }

    /**
     * 获取计算结果
     *
     * @return 计算结果
     */
    public BigDecimal getResult() {
        return result;
    }

}