[Java] Rechner programmieren

import java.util.Scanner;

Scanner tastatur = new Scanner(System.in);
String text;

text=tastatur.nextLine();

String myString = "xyz";
char [] myCharArray = myString.toCharArray ();

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String input = reader.readLine();

import java.util.NoSuchElementException;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.HashMap;
import java.util.regex.*;

/**
* token-class
*
* stores: double number (if available)
* String value
* int type
*/
class Token 
{
 public double number;
 public int type;
 public String value;
 
 /**
 * initializes a number-token
 *
 * @param double number
 */
 public Token(double number)
 {
 this.number = number;
 this.type = 0;
 this.value = new StringBuilder().append(number).toString();
 }
 
 /**
 * initializes a operator- or function-token
 *
 * @param int type
 * @param String value
 */
 public Token(int type, String value)
 {
 this.number = 0;
 this.type = type;
 this.value = value;
 }
};

/**
* callback-class
*/
class Callback
{
 public double exec(double number)
 {
 return .0;
 }
};

public class Parser
{ 
 //functiontable
 public HashMap functions = new HashMap();
 
 /**
 * main-method
 */
 public static void main(String args[])
 {
 if(args.length > 0) {
 Parser p = new Parser();
 System.out.println("result is: " + p.reduce(args[0]));
 }
 }
 
 /**
 * constructor
 */
 public Parser() 
 {
 //default functions
 this.functions.put("abs", new Callback() { public double exec(double number) { return Math.abs(number); } });
 this.functions.put("sqrt", new Callback() { public double exec(double number) { return Math.sqrt(number); } });
 this.functions.put("log", new Callback() { public double exec(double number) { return Math.log(number); } });
 }
 
 /**
 * tokenizes a expr
 *
 * @param String expr
 * @param LinkedList<Token> tokens
 * @return void
 */
 protected void tokenize(String expr, LinkedList<Token> tokens)
 {
 //tokenize-pattern
 Matcher match = Pattern.compile("[0-9]+\\.[0-9]+|[0-9]+|[:\\*\\+\\-/\\(\\)]|[a-z0-9]+").matcher(expr);
 //number-pattern
 Pattern numeric = Pattern.compile("[0-9]+\\.[0-9]+|[0-9]+");
 
 while(match.find()) {
 String token = expr.substring(match.start(), match.end());
 switch(token.charAt(0)) {
 case '+':
 tokens.add(new Token(1, "+"));
 break;
 case '-':
 tokens.add(new Token(2, "-"));
 break;
 case '*':
 tokens.add(new Token(3, "*"));
 break;
 case ':':
 case '/':
 tokens.add(new Token(4, "/"));
 break;
 case '(':
 tokens.add(new Token(5, "("));
 break;
 case ')':
 tokens.add(new Token(6, ")"));
 break;
 default:
 if(numeric.matcher(token).matches()) {
 tokens.add(new Token(Double.valueOf(token)));
 break;
 }
 
 tokens.add(new Token(7, token));
 }
 }
 
 
 }
 
 /**
 * prints a error-message and exits the application
 *
 * @param String error
 * @return void
 */
 protected void exitError(String error)
 {
 System.out.println(error);
 System.exit(1);
 }
 
 /**
 * executes a function and returns the result
 *
 * @param String func
 * @param LinkedList<Token> tokens
 * @return double
 */
 protected double execFunction(String func, LinkedList<Token> tokens)
 {
 if(((Token) tokens.remove(0)).type != 5)
 this.exitError("syntax error, expecting \"(\" after function-call " + func);
 
 double number = this.reduceParen(tokens);
 if(!this.functions.containsKey(func))
 this.exitError("undefined function " + func);
 
 return ((Callback) this.functions.get(func)).exec(number);
 }
 
 /**
 * parses stuff between ( ) to double
 *
 * @param LinkedList<Token> tokens
 * @return double
 */
 protected double reduceParen(LinkedList<Token> tokens)
 {
 LinkedList<Token> inner = new LinkedList<Token>();
 ListIterator i = tokens.listIterator();
 
 while(i.hasNext()) {
 Token token = (Token) tokens.remove(i.nextIndex());
 
 if(token.type == 6)
 return this.reduce(inner);
 else if(token.type == 5)
 token = new Token(this.reduceParen(tokens));
 else if(token.type == 7)
 token = new Token(this.execFunction(token.value, tokens));
 
 inner.add(token);
 }
 
 this.exitError("unexpected END, missing \")\"");
 return 0;
 }
 
 /**
 * pops a number from stack - unary "+" or "-" is not allowed!
 *
 * @param LinkedList<Token> tokens
 * @param boolean ...
 * @return double
 */
 protected double popNumber(LinkedList<Token> tokens, boolean _)
 {
 Token next;
 try {
 next = (Token) tokens.remove(0);
 } catch(NoSuchElementException e) {
 this.exitError("unepxected END, expecting number, function or ( expression )");
 return 0;
 }
 
 if(next.type != 0) {
 switch(next.type) {
 case 5:
 return this.reduceParen(tokens);
 case 7:
 return this.execFunction(next.value, tokens);
 default:
 this.exitError("unexpected " + next.value + ", expecting number, function or ( expresssion )");
 }
 }
 
 return next.number;
 }
 
 /**
 * pops a number from stack
 *
 * @param LinkedList<Token> tokens
 * @return double
 */
 protected double popNumber(LinkedList<Token> tokens)
 {
 Token next;
 
 try {
 next = (Token) tokens.remove(0);
 } catch(NoSuchElementException e) {
 this.exitError("unexpected END, expecting number, function or ( expression )");
 return 0;
 }
 
 if(next.type != 0) {
 switch(next.type) {
 case 5:
 return this.reduceParen(tokens);
 case 7:
 return this.execFunction(next.value, tokens);
 case 1:
 return this.popNumber(tokens, false);
 case 2:
 return -this.popNumber(tokens, false);
 default:
 this.exitError("unexpected token " + next.value + ", expecting number, function or ( expression )");
 }
 }
 
 return next.number;
 }
 
 /**
 * reduces expr*expr or expr/expr
 *
 * @param LinkedList<Token> tokens
 * @return void
 */
 protected LinkedList<Token> reduceTimesDiv(LinkedList<Token> tokens)
 {
 double result = this.popNumber(tokens);
 LinkedList<Token> newStack = new LinkedList<Token>();
 ListIterator i = tokens.listIterator();
 
 while(i.hasNext()) {
 Token token = (Token) tokens.remove(i.nextIndex());
 
 if(token.type == 0)
 this.exitError("unexpected number " + token.value + ", expecting operator");
 
 switch(token.type) {
 case 3:
 result *= this.popNumber(tokens);
 break;
 case 4:
 result /= this.popNumber(tokens);
 break;
 default:
 newStack.add(new Token(result));
 newStack.add(token);
 result = this.popNumber(tokens);
 break;
 }
 }
 
 newStack.add(new Token(result));
 return newStack;
 }
 
 /**
 * reduces expr+expr or expr-expr
 *
 * @param LinkedList<Token> tokens
 * @return double
 */
 double reduceAddSub(LinkedList<Token> tokens)
 {
 double result = this.popNumber(tokens);
 ListIterator i = tokens.listIterator();
 
 while(i.hasNext()) {
 Token token = (Token) tokens.remove(i.nextIndex());
 
 if(token.type == 0)
 this.exitError("unepxected number, expecting operator");
 
 switch(token.type) {
 case 1:
 result += this.popNumber(tokens);
 break;
 case 2:
 result -= this.popNumber(tokens);
 break;
 default:
 this.exitError("invalid expression");
 }
 }
 
 return result;
 }
 
 /**
 * compiles a expr to double
 *
 * @param String expr
 * @return double
 */
 public double reduce(String expr)
 {
 LinkedList<Token> tokens = new LinkedList<Token>();
 this.tokenize(expr, tokens);
 tokens = this.reduceTimesDiv(tokens);
 return this.reduceAddSub(tokens);
 }
 
 /**
 * compiles a stack of Token's to double
 *
 * @param LinkedList<Token> tokens
 * @return double
 */
 public double reduce(LinkedList<Token> tokens)
 {
 tokens = this.reduceTimesDiv(tokens);
 return this.reduceAddSub(tokens);
 }
};