this code analyse digits and operators only i need it to analyse alphabetic only and put invalid for other things what should i do in details i got this code from tutorial site and modified it but no result.

```
     package lexical;

     public class Tokenizer {

int pos;
char[] expression;

Tokenizer(String expression) {
    this.expression = expression.toCharArray();
    this.pos = 0;
}

enum Type { OPERATOR, LITTER, UNKNOWN }

class Lexeme {
    String type, token;
    Lexeme(String type, String token) {
        this.type = type;
        this.token = token;
    }
}

Lexeme getNextToken() {
    StringBuilder token = new StringBuilder();
    boolean endOfToken = false;
    Type type = Type.UNKNOWN;
    while (!endOfToken && hasMoreTokens()) {
        while(expression[pos] == ' ' && hasMoreTokens())
            pos++;
        switch (expression[pos]) {
            case '+':
            case '-':
            case '*':
            case '/':
                if(type != Type.LITTER) {
                    type = Type.OPERATOR;
                    token.append(expression[pos]);
                    pos++;
                }
                endOfToken = true;
                break;
            case ' ':
                endOfToken = true;
                pos++;
                break;
            default:
                if(Character.isDigit(expression[pos]) || expression[pos] == '.') {
                    token.append(expression[pos]);
                    type = Type.LITTER;
                } else {
                    System.out.println("Systax error at position: " + pos);
                }
                pos++;
                break;
        }
    }
    return new Lexeme(type.name().toLowerCase(), token.toString());
}

boolean hasMoreTokens() {
    return pos < expression.length;
}

public static void main(String[] args) {
    String expression = "54+18+5";
    Tokenizer tokenizer = new Tokenizer(expression);
    while (tokenizer.hasMoreTokens()) {
        Lexeme nextToken = tokenizer.getNextToken();
        System.out.print("Type: " + nextToken.type + "\tLexeme: " + nextToken.token + "\n");
    }
}

 }

```