java中字母的词法分析

这个代码只分析数字和运算符我需要它只分析字母，并把其他事情我应该做的细节无效我从教程网站上得到了这个代码，并修改了它，但没有结果

     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");
    }
}


 }

package；
公共类标记器{
int pos；
char[]表达式；
标记器（字符串表达式）{
this.expression=expression.toCharArray（）；
此值为0.pos；
}
枚举类型{运算符，垃圾，未知}
类词素{
字符串类型，令牌；
词素（字符串类型、字符串标记）{
this.type=type；
this.token=token；
}
}
Lexeme getNextToken（）{
StringBuilder令牌=新的StringBuilder（）；
布尔endOfToken=false；
Type=Type.UNKNOWN；
而（！endOfToken&&hasMoreTokens（））{
while（表达式[pos]=''&&hasMoreTokens（））
pos++；
开关（表达式[pos]）{
格“+”：
案例'-'：
案例“*”：
案例“/”：
如果（类型！=类型垃圾）{
type=type.OPERATOR；
token.append（表达式[pos]）；
pos++；
}
endOfToken=真；
打破
案例“”：
endOfToken=真；
pos++；
打破
违约：
if（Character.isDigit（表达式[pos]）| |表达式[pos]=='。）{
token.append（表达式[pos]）；
type=type.LITTER；
}否则{
System.out.println（“位置：+pos处的Systax错误”）；
}
pos++；
打破
}
}
返回新的Lexeme（type.name（）.toLowerCase（），token.toString（））；
}
布尔hasMoreTokens（）{
返回pos

本节是查找数字和 给出非数字或非句点字符的错误

if(Character.isDigit(expression[pos]) || expression[pos] == '.') {
     token.append(expression[pos]);
     type = Type.LITTER;
} else {
     System.out.println("Systax error at position: " + pos);
}

字符串可以正常地保存任何内容，因此您只需删除if语句并执行

default:
    token.append(expression[pos]);

但是，如果要限制字符串中的字符，请修改if条件以检查所需的字符。而不是：

if(Character.isDigit(expression[pos]) || expression[pos] == '.') {

将其更改为仅接受字符串中您认为有效的字符。比如说

if (Character.isAlphabetic(expression[pos]) || expression[pos] == "-") {

您可能还需要一个新的标识符，而不是

type = Type.LITTER;

---

我不知道你想如何处理“A12”或任何部分字母和部分数字的东西。此代码将为“A12”返回“A”

---

我正在尝试，因为你发布了你的答案，但是没有任何东西你可以发布所有检查所有字母的代码，任何东西都是无效的，提前感谢什么字符是字母-只是A-Z，A-Z？？字符是字母A-Z

package lexical;

public class Tokenizer {

    int pos;
    char[] expression;

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

    enum Type {

        OPERATOR, ALPHA, UNKNOWN, LITTER, ERROR
    }

    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;
        // skip whitespace
        while (expression[pos] == ' ' && hasMoreTokens()) {
            pos++;
        } 

        while (!endOfToken && hasMoreTokens()) {

            switch (expression[pos]) {
                case ' ':
                {
                    endOfToken = true;
                    pos++;
                    break;
                }
                default:
                    if (Character.isAlphabetic(expression[pos])) {                     
                        token.append(expression[pos]);
                        type = Type.ALPHA;                      
                    } 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) {
        expression = "Hello World";
        Tokenizer tokenizer = new Tokenizer(expression);
        while (tokenizer.hasMoreTokens()) {
            Lexeme nextToken = tokenizer.getNextToken();
            System.out.print("Type: " + nextToken.type + "\tLexeme: " + nextToken.token + "\n");
        }        
        expression = "123 ABC A12";
        tokenizer = new Tokenizer(expression);
        while (tokenizer.hasMoreTokens()) {
            Lexeme nextToken = tokenizer.getNextToken();
            System.out.print("Type: " + nextToken.type + "\tLexeme: " + nextToken.token + "\n");
        }        
    }
}

Type: alpha Lexeme: Hello
Type: alpha Lexeme: World
Systax error at position: 0
Systax error at position: 1
Systax error at position: 2
Type: unknown   Lexeme: 
Type: alpha Lexeme: ABC
Systax error at position: 9
Systax error at position: 10
Type: alpha Lexeme: A