if (Character.isWhitespace(i) | !Character.isLetter(i)){是什么意思

这段代码的作用是判断一个字符是否为空格或者不是字母。其中，Character.isWhitespace(i)用于判断字符i是否为空格，!Character.isLetter(i)用于判断字符i是否不是字母。如果字符i为空格或者不是字母，条件表达式的值为true，如果不是，条件表达式的值为false。这段代码通常用于过滤掉文本中的非字母和空格字符。

相关问题

You are to write a lexical analyzer/scanner for the language decaf in java. Goals: 1. The input of the scanner is a source code file and the output of the scanner is a stream of tokens. 2. Your scanner should go for longest possible match i.e. a string ‘:=’is to be identified as ‘ass-symbol’ and not as ‘:’and ‘=’. 3. Token is represented as (Kind, Value). We use the following symbols to denote different kinds of tokens KEY denotes reserved words SYM denotes special symbols ID denotes identifiers NUM denotes numeric constants STR denotes string constants 4. Check lexical errors: giving meaning error messages and the lines where errors occur. The kinds of lexical errors are: - Illegal character, that is, scanner may recognize a character that is not in the alphabet of TINY+ - The right bracket of a STRING is lost - The right delimiter of a comment is lost

Sure, I can help you with that! Here's a sample code for a lexical analyzer/scanner for the decaf language in Java:

import java.io.*;
import java.util.*;

public class Scanner {
    private BufferedReader br;
    private char currentChar;
    private int currentLineNum;
    private String currentTokenValue;

    // reserved words
    private static final Map<String, Token.Kind> reservedWords = new HashMap<>();
    static {
        reservedWords.put("class", Token.Kind.CLASS);
        reservedWords.put("extends", Token.Kind.EXTENDS);
        reservedWords.put("static", Token.Kind.STATIC);
        reservedWords.put("void", Token.Kind.VOID);
        reservedWords.put("main", Token.Kind.MAIN);
        reservedWords.put("public", Token.Kind.PUBLIC);
        reservedWords.put("private", Token.Kind.PRIVATE);
        reservedWords.put("int", Token.Kind.INT);
        reservedWords.put("boolean", Token.Kind.BOOLEAN);
        reservedWords.put("if", Token.Kind.IF);
        reservedWords.put("else", Token.Kind.ELSE);
        reservedWords.put("while", Token.Kind.WHILE);
        reservedWords.put("return", Token.Kind.RETURN);
        reservedWords.put("true", Token.Kind.TRUE);
        reservedWords.put("false", Token.Kind.FALSE);
        reservedWords.put("this", Token.Kind.THIS);
        reservedWords.put("new", Token.Kind.NEW);
    }

    // special symbols
    private static final Map<String, Token.Kind> specialSymbols = new HashMap<>();
    static {
        specialSymbols.put("(", Token.Kind.LPAREN);
        specialSymbols.put(")", Token.Kind.RPAREN);
        specialSymbols.put("{", Token.Kind.LBRACE);
        specialSymbols.put("}", Token.Kind.RBRACE);
        specialSymbols.put("[", Token.Kind.LBRACKET);
        specialSymbols.put("]", Token.Kind.RBRACKET);
        specialSymbols.put(".", Token.Kind.DOT);
        specialSymbols.put(",", Token.Kind.COMMA);
        specialSymbols.put(";", Token.Kind.SEMICOLON);
        specialSymbols.put("=", Token.Kind.ASSIGN);
        specialSymbols.put("!", Token.Kind.NOT);
        specialSymbols.put("&", Token.Kind.AND);
        specialSymbols.put("|", Token.Kind.OR);
        specialSymbols.put("<", Token.Kind.LT);
        specialSymbols.put(">", Token.Kind.GT);
        specialSymbols.put("==", Token.Kind.EQUAL);
        specialSymbols.put("!=", Token.Kind.NOTEQUAL);
        specialSymbols.put("<=", Token.Kind.LE);
        specialSymbols.put(">=", Token.Kind.GE);
        specialSymbols.put("+", Token.Kind.ADD);
        specialSymbols.put("-", Token.Kind.SUB);
        specialSymbols.put("*", Token.Kind.MUL);
        specialSymbols.put("/", Token.Kind.DIV);
        specialSymbols.put("%", Token.Kind.MOD);
    }

    public Scanner(String filename) throws IOException {
        br = new BufferedReader(new FileReader(filename));
        currentLineNum = 1;
        currentChar = (char) br.read();
    }

    private void getNextChar() throws IOException {
        if (currentChar == '\n') {
            currentLineNum++;
        }
        currentChar = (char) br.read();
    }

    private boolean isWhitespace(char c) {
        return c == ' ' || c == '\t' || c == '\r' || c == '\n';
    }

    private boolean isDigit(char c) {
        return c >= '0' && c <= '9';
    }

    private boolean isLetter(char c) {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }

    private boolean isLegalCharacter(char c) {
        return isWhitespace(c) || isDigit(c) || isLetter(c) || specialSymbols.containsKey(Character.toString(c));
    }

    private void skipWhitespace() throws IOException {
        while (isWhitespace(currentChar)) {
            getNextChar();
        }
    }

    private Token scanIdentifierOrKeyword() throws IOException {
        StringBuilder sb = new StringBuilder();
        while (isLetter(currentChar) || isDigit(currentChar) || currentChar == '_') {
            sb.append(currentChar);
            getNextChar();
        }
        String tokenValue = sb.toString();
        Token.Kind kind = reservedWords.getOrDefault(tokenValue, Token.Kind.ID);
        return new Token(kind, tokenValue, currentLineNum);
    }

    private Token scanNumber() throws IOException {
        StringBuilder sb = new StringBuilder();
        while (isDigit(currentChar)) {
            sb.append(currentChar);
            getNextChar();
        }
        String tokenValue = sb.toString();
        return new Token(Token.Kind.NUM, tokenValue, currentLineNum);
    }

    private Token scanString() throws IOException {
        StringBuilder sb = new StringBuilder();
        getNextChar();
        while (currentChar != '"') {
            if (currentChar == '\n' || currentChar == -1) {
                throw new LexicalException("Unterminated string", currentLineNum);
            }
            sb.append(currentChar);
            getNextChar();
        }
        getNextChar();
        return new Token(Token.Kind.STR, sb.toString(), currentLineNum);
    }

    private Token scanComment() throws IOException {
        getNextChar();
        getNextChar();
        while (!(currentChar == '*' && br.read() == '/')) {
            if (currentChar == '\n') {
                currentLineNum++;
            }
            getNextChar();
        }
        getNextChar();
        return getNextToken();
    }

    private Token scanSpecialSymbol() throws IOException {
        StringBuilder sb = new StringBuilder();
        while (specialSymbols.containsKey(sb.toString() + currentChar)) {
            sb.append(currentChar);
            getNextChar();
        }
        String tokenValue = sb.toString();
        Token.Kind kind = specialSymbols.get(tokenValue);
        if (kind == null) {
            throw new LexicalException("Illegal character: " + tokenValue, currentLineNum);
        }
        return new Token(kind, tokenValue, currentLineNum);
    }

    public Token getNextToken() throws IOException {
        while (isWhitespace(currentChar)) {
            skipWhitespace();
        }
        if (currentChar == -1) {
            return new Token(Token.Kind.EOF, "", currentLineNum);
        }
        if (!isLegalCharacter(currentChar)) {
            throw new LexicalException("Illegal character: " + currentChar, currentLineNum);
        }
        if (currentChar == '/') {
            getNextChar();
            if (currentChar == '/') {
                while (currentChar != '\n' && currentChar != -1) {
                    getNextChar();
                }
                return getNextToken();
            } else if (currentChar == '*') {
                return scanComment();
            } else {
                return new Token(Token.Kind.DIV, "/", currentLineNum);
            }
        }
        if (isLetter(currentChar)) {
            return scanIdentifierOrKeyword();
        }
        if (isDigit(currentChar)) {
            return scanNumber();
        }
        if (currentChar == '"') {
            return scanString();
        }
        if (specialSymbols.containsKey(Character.toString(currentChar))) {
            return scanSpecialSymbol();
        }
        throw new LexicalException("Illegal character: " + currentChar, currentLineNum);
    }

    public static class LexicalException extends RuntimeException {
        private int lineNum;

        public LexicalException(String message, int lineNum) {
            super(message);
            this.lineNum = lineNum;
        }

        public int getLineNum() {
            return lineNum;
        }
    }
}

This code reads in a source code file and returns a stream of tokens. It uses a map to store the reserved words and special symbols, and uses a series of `if` statements to determine what kind of token it is dealing with. It also handles lexical errors by throwing a `LexicalException` with a meaningful error message and the line number where the error occurred.

java Character

Java Character类是一个包装类，它提供了一些用于操作基本数据类型 char 的方法。Character类的常用方法包括：

- `isLetter(char ch)`：判断字符是否为字母。
- `isDigit(char ch)`：判断字符是否为数字。
- `isWhitespace(char ch)`：判断字符是否为空白字符。
- `toLowerCase(char ch)`：将字符转换为小写。
- `toUpperCase(char ch)`：将字符转换为大写。
- `toString(char ch)`：将字符转换为字符串。

除了以上方法，Character类还有许多其他方法，可在Java官方文档中查看。需要注意的是，由于Character类是一个包装类，所以在使用时需要将char类型的值先转换为Character对象。例如：

char ch = 'A';
Character character = new Character(ch);
boolean isLetter = character.isLetter(); // 判断是否为字母

在Java 9之后，推荐使用静态工厂方法 `Character.valueOf(char ch)` 来创建Character对象，例如：

char ch = 'A';
Character character = Character.valueOf(ch);
boolean isLetter = character.isLetter(); // 判断是否为字母