Как исправить так, чтобы массив результатов записывался в файл?

public class ExpressionUtils {
    InputStream fis;
    OutputStream fos;
    BufferedReader br;
    String line;
    public ArrayList<String> results = new ArrayList<String>();
    public static final Map<String, Integer> MAIN_MATH_OPERATIONS = new HashMap<String, Integer>();
 
    static {
        MAIN_MATH_OPERATIONS.put("*", 1);
        MAIN_MATH_OPERATIONS.put("/", 1);
        MAIN_MATH_OPERATIONS.put("+", 2);
        MAIN_MATH_OPERATIONS.put("-", 2);
        MAIN_MATH_OPERATIONS.put("sin", 1);
        MAIN_MATH_OPERATIONS.put("cos", 1);
        MAIN_MATH_OPERATIONS.put("tg", 1);
        MAIN_MATH_OPERATIONS.put("log", 1);
        MAIN_MATH_OPERATIONS.put("^", 1);
    }
 
    public void read() throws IOException {
        try {
            fis = new
                    FileInputStream("input.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        br = new
                BufferedReader(new InputStreamReader(fis, Charset.forName("UTF-8")));
        while ((line = br.readLine()) != null) {
            StringBuilder currentResult = new StringBuilder();
            currentResult.append(line + "=" + calculate(line));
            results.add(currentResult.toString());
            PrintWriter pw = new PrintWriter(new File("output.txt"));
            pw.println(results);
        }
        br.close();
        br = null;
        fis = null;
    }
 
    public static String sortingStation(String expression, Map<String, Integer> operations,
                                        String leftBracket, String rightBracket) {
        if (expression == null || expression.length() == 0)
            throw new IllegalStateException("Expression isn't specified.");
        if (operations == null || operations.isEmpty())
            throw new IllegalStateException("Operations aren't specified.");
        // Выходная строка, разбитая на "символы" - операции и операнды.
        List<String> out = new ArrayList<String>();
        // Стек операций.
        Stack<String> stack = new Stack<String>();
 
        // Удаление пробелов из выражения.
        expression = expression.replace(" ", "");
 
        // Множество "символов", не являющихся операндами (операции и скобки).
        Set<String> operationSymbols = new HashSet<String>(operations.keySet());
        operationSymbols.add(leftBracket);
        operationSymbols.add(rightBracket);
 
        // Индекс, на котором закончился разбор строки на прошлой итерации.
        int index = 0;
        // Признак необходимости поиска следующего элемента.
        boolean findNext = true;
        while (findNext) {
            int nextOperationIndex = expression.length();
            String nextOperation = "";
            // Поиск следующего оператора или скобки.
            for (String operation : operationSymbols) {
                int i = expression.indexOf(operation, index);
                if (i >= 0 && i < nextOperationIndex) {
                    nextOperation = operation;
                    nextOperationIndex = i;
                }
            }
            if (nextOperationIndex == expression.length()) {
                findNext = false;
            } else {
                // Если оператору или скобке предшествует операнд, добавляем его в выходную строку.
                if (index != nextOperationIndex) {
                    out.add(expression.substring(index, nextOperationIndex));
                }
                // Обработка операторов и скобок.
                // Открывающая скобка.
                if (nextOperation.equals(leftBracket)) {
                    stack.push(nextOperation);
                }
                // Закрывающая скобка.
                else if (nextOperation.equals(rightBracket)) {
                    while (!stack.peek().equals(leftBracket)) {
                        out.add(stack.pop());
                        if (stack.empty()) {
                            throw new IllegalArgumentException("Unmatched brackets");
                        }
                    }
                    stack.pop();
                }
                // Операция.
                else {
                    while (!stack.empty() && !stack.peek().equals(leftBracket) &&
                            (operations.get(nextOperation) >= operations.get(stack.peek()))) {
                        out.add(stack.pop());
                    }
                    stack.push(nextOperation);
                }
                index = nextOperationIndex + nextOperation.length();
            }
        }
        // Добавление в выходную строку операндов после последнего операнда.
        if (index != expression.length()) {
            out.add(expression.substring(index));
        }
        // Преобразование выходного списка к выходной строке.
        while (!stack.empty()) {
            out.add(stack.pop());
        }
        StringBuffer result = new StringBuffer();
        if (!out.isEmpty())
            result.append(out.remove(0));
        while (!out.isEmpty())
            result.append(" ").append(out.remove(0));
 
        return result.toString();
 
    }
 
    public static String sortingStation(String expression, Map<String, Integer> operations) {
        return sortingStation(expression, operations, "(", ")");
    }
 
    public static BigDecimal calculate(String expression) {
        String rpn = sortingStation(expression, MAIN_MATH_OPERATIONS);
        StringTokenizer tokenizer = new StringTokenizer(rpn, " ");
        Stack<BigDecimal> stack = new Stack<BigDecimal>();
        while (tokenizer.hasMoreTokens()) {
            String token = tokenizer.nextToken();// Операнд.
            if (!MAIN_MATH_OPERATIONS.keySet().contains(token)) {
                stack.push(new BigDecimal(token));
            } else {
                BigDecimal operand2 = stack.pop();
                BigDecimal operand1 = stack.empty() ? BigDecimal.ZERO : stack.pop();
                if (token.equals("*")) {
                    stack.push(operand1.multiply(operand2));
                } else if (token.equals("/")) {
                    stack.push(operand1.divide(operand2));
                } else if (token.equals("+")) {
                    stack.push(operand1.add(operand2));
                } else if (token.equals("-")) {
                    stack.push(operand1.subtract(operand2));
                } else if (token.equals("^")) {
                    stack.push(operand1.pow(Integer.valueOf(String.valueOf(operand2))));
                } else if (token.equals("sin")) {
                    stack.push(BigDecimal.valueOf(Math.sin(Double.valueOf(String.valueOf(operand2)))));
                } else if (token.equals("cos")) {
                    stack.push(BigDecimal.valueOf(Math.cos(Double.valueOf(String.valueOf(operand2)))));
                } else if (token.equals("tg")) {
                    stack.push(BigDecimal.valueOf(Math.tan(Double.valueOf(String.valueOf(operand2)))));
                } else if (token.equals("log")) {
                    stack.push(BigDecimal.valueOf(Math.log(Double.valueOf(String.valueOf(operand2)))));
                }
            }
        }
        if (stack.size() != 1)
            throw new IllegalArgumentException("Expression syntax error.");
        return stack.pop();
    }
}
 
import java.io.IOException;
 
/**
 * Created by User on 11.06.2014.
 */
public class MainClass {
    public static void main(String[] args) throws IOException {
        ExpressionUtils main = new ExpressionUtils();
        main.read();
    }
}