2) Found two ways to convert characters to integers:

    for (int i=0; i<line.length(); i++) {
      String s = line.substring(i,i+1);
      System.out.print (Integer.valueOf(s)+".");
      int value = (int)(line.charAt(i) - '0');
      System.out.print (value);
    } 

5) Identified the characters in a String

    for (int i=0; i<line.length(); i++) {
      char c = line.charAt(i);

      if (Character.isDigit (c)) {
	System.out.println ("Operand");
      } else if (isOperator (c)) {
	System.out.println ("Operator");
      } else {
	System.out.println ("Error");
      }
    }

6) Wrote precedence and outranks

  public static int precedence (char c) {
    switch (c) {
    case '+': case '-':
      return 0;
    case '*': case '/':
      return 1;
    default:
      System.out.println ("Error in precedence: non-operator");
      System.exit(1);
    }    
  }

  public static boolean outranks (char c, char d) {
    return (precedence(c) > precedence (d));
  }

7) Copy a String into a StringBuffer

    StringBuffer out = new StringBuffer (line.length());

    for (int i=0; i<line.length(); i++) {
      out.append (line.charAt(i));
    }
    System.out.println (out);

8) Implement the expression evaluator.

  public static int evaluate (String line) {
    Stack stack = new Stack ();

    for (int i=0; i<line.length(); i++) {
      char c = line.charAt(i);

      if (Character.isDigit (c)) {
	int operand = charToInt (c);
	stack.push (new Integer (operand));
      } else if (isOperator (c)) {
	int op2 = ((Integer) stack.pop()).intValue();
	int op1 = ((Integer) stack.pop()).intValue();
	int res = operate (op1, op2, c);
	stack.push (new Integer (res));
      } else {
	System.out.println ("Error");
      }
    }
    int res = ((Integer) stack.pop()).intValue();
    return res;
  }

9) I implemented a simplified version of the translator that
   doesn't handle parentheses.

  public static StringBuffer translate (String line) {
    StringBuffer out = new StringBuffer (line.length());
    Stack stack = new Stack ();

    for (int i=0; i<line.length(); i++) {
      char c = line.charAt(i);

      if (Character.isDigit (c)) {
	out.append (c);
      } else if (isOperator (c)) {
	dealWithOperator (c, out, stack);
      } else {
	System.out.println ("Error");
      }
    }
    while (!stack.empty()) {
      char operator = ((Character) stack.pop()).charValue();
      out.append (operator);
    }
    return out;
  }

  public static void dealWithOperator
    (char operator, StringBuffer out, Stack stack) {

    while (!stack.empty()) {
      char pending = ((Character) stack.peek()).charValue();
      if (outranks (operator, pending)) {
	break;
      } else {
	pending = ((Character) stack.pop()).charValue();
	out.append (pending);
      }
    }
    stack.push (new Character (operator));
    return;
  }

11) Now let's add parentheses:

  public static void dealWithCloser
    (StringBuffer out, Stack stack) {

    while (!stack.empty()) {
      char pending = ((Character) stack.pop()).charValue();
      if (pending == '(') break;
      out.append (pending);
    }
  }

  public static void dealWithOperator
    (char operator, StringBuffer out, Stack stack) {

    while (!stack.empty()) {
      char pending = ((Character) stack.peek()).charValue();
      if (pending == '(') break;

      if (outranks (operator, pending)) {
	break;
      } else {
	pending = ((Character) stack.pop()).charValue();
	out.append (pending);
      }
    }
    stack.push (new Character (operator));
    return;
  }

  public static StringBuffer translate (String line) {
    StringBuffer out = new StringBuffer (line.length());
    Stack stack = new Stack ();

    for (int i=0; i<line.length(); i++) {
      char c = line.charAt(i);

      if (Character.isDigit (c)) {
	out.append (c);
      } else if (isOperator (c)) {
	dealWithOperator (c, out, stack);
      } else if (c == '(') {
	stack.push (new Character (c));
      } else if (c == ')') {
	dealWithCloser (out, stack);
      } else {
	System.out.println ("Error unknown character:" + c);
      }
    }
    while (!stack.empty()) {
      char operator = ((Character) stack.pop()).charValue();
      out.append (operator);
    }
    return out;
  }

12) Last step is to put it all together:

      StringBuffer postfix = translate (infix);
      System.out.println (postfix);
      int res = evaluate (postfix);
      System.out.println (res);