Merge pull request #18317 from martin-blazevic/article/BAEL-9016

davidmartinezbarua · web-flow · commit 077a202833db · 2025-02-24T14:26:24.000-03:00
article/BAEL-9016
diff --git a/core-java-modules/core-java-23/src/main/java/com/baeldung/javafeatures/ImplicitClass.java b/core-java-modules/core-java-23/src/main/java/com/baeldung/javafeatures/ImplicitClass.java
@@ -1,3 +1,6 @@
+import static java.io.IO.print;
+import static java.io.IO.readln;
+
 void main() {
     String name = readln("Please enter your name: ");
     print("Hello "+name);
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/Expression.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/Expression.java
@@ -0,0 +1,29 @@
+package com.baeldung.lexer;
+
+import java.util.Optional;
+
+public class Expression {
+
+    private final String value;
+    private int index = 0;
+
+    public Expression(String value) {
+        this.value = value != null ? value : "";
+    }
+
+    public Optional<Character> next() {
+        if (index >= value.length()) {
+            return Optional.empty();
+        }
+        return Optional.of(value.charAt(index++));
+    }
+
+    public boolean hasNext() {
+        return index < value.length();
+    }
+
+    public String getValue() {
+        return value;
+    }
+}
+
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/InvalidExpressionException.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/InvalidExpressionException.java
@@ -0,0 +1,8 @@
+package com.baeldung.lexer;
+
+class InvalidExpressionException extends RuntimeException {
+
+    public InvalidExpressionException(String message) {
+        super(message);
+    }
+}
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/Lexer.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/Lexer.java
@@ -0,0 +1,11 @@
+package com.baeldung.lexer;
+
+import java.util.List;
+
+public interface Lexer {
+
+    String MESSAGE_ERROR = "Unexpected entry: '%s'";
+
+    List<Token> tokenize(Expression expression);
+
+}
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/LexerFsm.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/LexerFsm.java
@@ -0,0 +1,117 @@
+package com.baeldung.lexer;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class LexerFsm implements Lexer {
+
+    public List<Token> tokenize(Expression expression) {
+        State state = State.INITIAL;
+        StringBuilder currentToken = new StringBuilder();
+        ArrayList<Token> tokens = new ArrayList<>();
+
+        while (expression.hasNext()) {
+            final Character currentChar = getValidNextCharacter(expression);
+
+            switch (state) {
+                case INITIAL:
+                    if (Grammar.isWhitespace(currentChar)) {
+                        break;
+                    } else if (Grammar.isDigit(currentChar)) {
+                        state = State.NUMBER;
+                        currentToken.append(currentChar);
+                    } else if (Grammar.isOperator(currentChar) && !tokens.isEmpty()) { // to ensure there are no expressions starting with an OPERATOR
+                        state = State.OPERATOR;
+                        currentToken.append(currentChar);
+                    } else {
+                        state = State.INVALID;
+                        currentToken.append(currentChar);
+                    }
+                    break;
+
+                case NUMBER:
+                    if (Grammar.isDigit(currentChar)) {
+                        currentToken.append(currentChar);
+                    } else {
+                        tokens.add(new TokenNumber(currentToken.toString()));
+                        currentToken.setLength(0);
+                        state = State.INITIAL;
+                    }
+                    break;
+
+                case OPERATOR:
+                    tokens.add(new TokenOperator(currentToken.toString()));
+                    currentToken.setLength(0);
+                    state = State.INITIAL;
+                    continue;
+
+                case INVALID:
+                    throw new InvalidExpressionException(String.format(MESSAGE_ERROR, currentToken));
+            }
+        }
+
+        finalizeToken(state, currentToken, tokens);
+
+        return tokens;
+    }
+
+    private static Character getValidNextCharacter(Expression expression) {
+        final Optional<Character> currentChar = expression.next();
+
+        if (!currentChar.isPresent() || !Grammar.isValidSymbol(currentChar.get())) {
+            throw new InvalidExpressionException(String.format(MESSAGE_ERROR, currentChar));
+        }
+
+        return currentChar.get();
+    }
+
+    private static void finalizeToken(State state, StringBuilder currentToken, ArrayList<Token> tokens) {
+        if (State.INVALID == state || State.OPERATOR == state) {
+            throw new InvalidExpressionException(String.format(MESSAGE_ERROR, currentToken));
+        } else if (State.NUMBER == state) {
+            tokens.add(new TokenNumber(currentToken.toString()));
+        }
+    }
+
+    private enum State {
+        INITIAL,
+        NUMBER,
+        OPERATOR,
+        INVALID
+    }
+
+    private enum Grammar {
+        ADDITION('+'),
+        SUBTRACTION('-'),
+        MULTIPLICATION('*'),
+        DIVISION('/');
+
+        private final char symbol;
+
+        Grammar(char symbol) {
+            this.symbol = symbol;
+        }
+
+        public static boolean isOperator(char character) {
+            return Arrays.stream(Grammar.values())
+                .anyMatch(grammar -> grammar.symbol == character);
+        }
+
+        public static boolean isDigit(char character) {
+            return Character.isDigit(character);
+        }
+
+        public static boolean isWhitespace(char character) {
+            return Character.isWhitespace(character);
+        }
+
+        public static boolean isValidSymbol(char character) {
+            return isOperator(character) || isWhitespace(character) || isDigit(character);
+        }
+
+    }
+
+}
+
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/LexerRegex.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/LexerRegex.java
@@ -0,0 +1,49 @@
+package com.baeldung.lexer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+class LexerRegex implements Lexer {
+
+    private static final String NUMBER_REGEX = "\\d+";
+    private static final String OPERATOR_REGEX = "[+\\-*/]";
+    private static final String WHITESPACE_REGEX = "\\s+";
+    private static final String VALID_EXPRESSION_REGEX = "^(" + NUMBER_REGEX + "(" + OPERATOR_REGEX + NUMBER_REGEX + ")*|" + NUMBER_REGEX + " )$";
+
+    private static final Pattern TOKEN_PATTERN = Pattern.compile(NUMBER_REGEX + "|" + OPERATOR_REGEX + "|" + WHITESPACE_REGEX);
+
+    private LexerRegex() {
+    }
+
+    public List<Token> tokenize(Expression expression) {
+        List<Token> tokens = new ArrayList<>();
+        Matcher matcher = TOKEN_PATTERN.matcher(expression.getValue());
+
+        if (!expression.getValue()
+            .matches(VALID_EXPRESSION_REGEX)) {
+            throw new InvalidExpressionException(String.format(MESSAGE_ERROR, expression));
+        }
+
+        while (matcher.find()) {
+            String match = matcher.group();
+            createToken(match).ifPresent(tokens::add);
+        }
+
+        return tokens;
+    }
+
+    private static Optional<Token> createToken(String match) {
+        if (match.matches(NUMBER_REGEX)) {
+            return Optional.of(new TokenNumber(match));
+        } else if (match.matches(OPERATOR_REGEX)) {
+            return Optional.of(new TokenOperator(match));
+        } else if (match.matches(WHITESPACE_REGEX)) {
+            return Optional.empty();
+        } else {
+            throw new InvalidExpressionException(String.format(MESSAGE_ERROR, match));
+        }
+    }
+}
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/Token.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/Token.java
@@ -0,0 +1,21 @@
+package com.baeldung.lexer;
+
+public abstract class Token {
+
+    private final String value;
+    private final TokenType type;
+
+    protected Token(TokenType type, String value) {
+        this.type = type;
+        this.value = value;
+    }
+
+    public TokenType getType() {
+        return type;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+}
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/TokenNumber.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/TokenNumber.java
@@ -0,0 +1,13 @@
+package com.baeldung.lexer;
+
+public class TokenNumber extends Token {
+
+    protected TokenNumber(String value) {
+        super(TokenType.NUMBER, value);
+    }
+
+    public int getValueAsInt() {
+        return Integer.parseInt(getValue());
+    }
+
+}
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/TokenOperator.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/TokenOperator.java
@@ -0,0 +1,8 @@
+package com.baeldung.lexer;
+
+public class TokenOperator extends Token {
+
+    protected TokenOperator(String value) {
+        super(TokenType.OPERATOR, value);
+    }
+}
diff --git a/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/TokenType.java b/core-java-modules/core-java-string-algorithms-5/src/main/java/com/baeldung/lexer/TokenType.java
@@ -0,0 +1,6 @@
+package com.baeldung.lexer;
+
+public enum TokenType {
+    NUMBER,
+    OPERATOR,
+}
diff --git a/core-java-modules/core-java-string-algorithms-5/src/test/java/com/baeldung/lexer/LexerTest.java b/core-java-modules/core-java-string-algorithms-5/src/test/java/com/baeldung/lexer/LexerTest.java
@@ -0,0 +1,64 @@
+package com.baeldung.lexer;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class LexerTest {
+
+    private final Lexer lexer = new LexerFsm();
+
+    @ParameterizedTest
+    @ValueSource(strings = { "1 + 2 $ 3", "1 - 2 #", "- 1 + 2", "+ 1 2" })
+    void givenInputContainsInvalidCharacters_whenTokenize_thenExceptionThrown(String input) {
+        assertThrows(Exception.class, () -> lexer.tokenize(new Expression(input)));
+    }
+
+    @Test
+    void givenInputIsSimpleExpression_whenTokenize_thenValidTokensIsReturned() {
+        String input = "3 + 50";
+        List<Token> tokens = lexer.tokenize(new Expression(input));
+
+        assertAll(() -> assertEquals(3, tokens.size(), "Token count mismatch"),
+
+            () -> assertToken(tokens.get(0), TokenType.NUMBER, "3"),
+
+            () -> assertToken(tokens.get(1), TokenType.OPERATOR, "+"),
+
+            () -> assertToken(tokens.get(2), TokenType.NUMBER, "50"));
+    }
+
+    private void assertToken(Token token, TokenType expectedType, String expectedValue) {
+        assertAll(() -> assertEquals(expectedType, token.getType(), "Token type mismatch"),
+            () -> assertEquals(expectedValue, token.getValue(), "Token value mismatch"));
+    }
+
+    @Test
+    void givenInputIsEmptyExpression_whenTokenize_thenEmptyListIsReturned() {
+        String input = "";
+        List<Token> tokens = lexer.tokenize(new Expression(input));
+
+        assertTrue(tokens.isEmpty(), "Lexer should return an empty list when the input expression is empty");
+    }
+
+    @Test
+    void givenInputIsNumber_whenTokenize_thenTokenNumberIsReturned() {
+        String input = "1";
+        List<Token> tokens = lexer.tokenize(new Expression(input));
+
+        assertAll(() -> assertEquals(1, tokens.size(), "Token count mismatch"),
+
+            () -> assertInstanceOf(TokenNumber.class, tokens.get(0)),
+
+            () -> assertEquals(1, ((TokenNumber) tokens.get(0)).getValueAsInt()));
+    }
+}
+
