如果我在示例输入上运行您的代码，我看不到您描述的行为。文字 helloString 等不被识别为类型的标记 Type_String ，但作为类型的标记 Identifier ，我认为这是预期的行为。所以这部分实际上工作得很好。
不好用的是 String 它本身也被识别为一个标识符。其原因是，如果两个规则可以产生相同长度的匹配，则选择最先出现的规则。在定义字符串关键字的规则之前，您已经定义了标识符的规则，所以总是选择它。如果你改变这两条规则， String 其本身将被视为 Type_String 其他一切都会被识别为一个标识符。

我不知道您使用的编译器语言，但我可以用java给您提供解决方案。在java中，可以使用正则表达式， (?<!\S)String(?=\s|$) 这意味着 String 不在前面加上（称为负向后看，由指定） ?<! )非空白字符（即。 \S )后跟（称为正向前瞻，由指定） ?= )空白字符（即。 \s )或（即。 | )字符串的结尾（即“$”）。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String str = "String helloString String Stringhello helloStringhello x String";
        String regex = "(?<!\\S)String(?=\\s|$)";
        Matcher matcher = Pattern.compile(regex).matcher(str);
        while (matcher.find()) {
            System.out.printf("'%s' found at %d%n", matcher.group(), matcher.start());
        }
    }
}

输出：

'String' found at 0
'String' found at 19
'String' found at 57

这是我的第二个jlex代码：

import java.io.*;
enum TokenType {OutPut_Instruction,Quoted_Stentence,Semi,L_Pracet,R_Pracet,Type_int,Type_double,Type_String,Identifier}
class Token{
    String text;
  TokenType type;
  Token(TokenType type,String text)
  {
    this.text=text;
    this.type=type;
  }

  public String toString()
  {
    return String.format("[%s,%s]",type,text);
  }
}
%%
%class Lexer
%public
%function getNextToken
%type Token
%{
     public static void main(String[] args) throws IOException {
        FileReader r = new FileReader("in.txt");
        Lexer l = new Lexer(r);
        Token tok;
        while((tok=l.getNextToken())!=null){
            System.out.println(tok);
        } 
        r.close();
    }
%}
%line
%char
SPACE=[\r\t\n\f\ ]
SEMI_COLO=[;]
L_P=[(]
R_P=[)]
DOUBLE_COT="\""([^\n\"]*(\\[.])*)*"\""
PRINT=(Print)
ALPHA=[a-zA-Z]
DIGIT=[0-9]
INT=(int)
DOUBLE=(double)
STRING=(String)
TYPE=(int)|(double)|(String)
ID=({ALPHA}|_)({ALPHA}|{DIGIT}|_)*

%%
<YYINITIAL> {L_P} {return new Token(TokenType.L_Pracet,yytext());}
<YYINITIAL> {R_P} {return new Token(TokenType.R_Pracet,yytext());}
<YYINITIAL> {SEMI_COLO} {return new Token(TokenType.Semi,yytext());}
<YYINITIAL> {PRINT} {return new Token(TokenType.OutPut_Instruction,yytext());}
<YYINITIAL> [^{TYPE}\ ]{ID} {return new Token(TokenType.Identifier,yytext());}
<YYINITIAL> {INT} {return new Token(TokenType.Type_int,yytext());}
<YYINITIAL> {DOUBLE} {return new Token(TokenType.Type_double,yytext());}
<YYINITIAL> {STRING} {return new Token(TokenType.Type_String,yytext());}
<YYINITIAL> {DOUBLE_COT} {return new Token(TokenType.Quoted_Stentence,yytext());}
<YYINITIAL> {SPACE}* {}
<YYINITIAL> . {System.out.println("error - "+yytext());}

这是输入

ah String ah Stringahmredgah Sahmed String int 这是输出

[Identifier,ah]
[Type_String,String]
[Identifier,ah]
[Type_String,String]
[Identifier,ahmredgah]
error - S
[Identifier,ahmed]
[Type_String,String]
[Type_int,int]