Merge branch 'dominicsbranch' into 'main'

Dominicsbranch

See merge request !2

src/Application.java

-public class Application {
+import java.util.Arrays;
+import java.util.List;
 
+public class Application {
+    public static void main(String[] args) {
+        List<String> test = Arrays.asList("1 + xy^2 - (31 * x)y");
+        for (String value: test) {
+            List<Lexer.Token> tokens = Lexer.lex(value);
+            for(Lexer.Token singleToken: tokens) {
+                System.out.println(singleToken.toString());
+            }
+        }
+    }
 }

src/Lexer.java

+import java.util.LinkedList;
+import java.util.List;
+
 public class Lexer {
+    public static enum TokenType {
+        NUMBER, VARIABLE, SPECIAL
+    }
+
+    public static class Token {
+        protected TokenType type;
+        protected String data;
+        public Token(TokenType type, String data) {
+            this.type = type;
+            this.data = data;
+        }
+
+        public TokenType getType() {
+            return type;
+        }
+
+        public String getData() {
+            return data;
+        }
+
+        @Override
+        public String toString() {
+            return String.format("type: %s, data: %s", type, data);
+        }
+    }
+
+    public static List<Token> lex(String input) {
+        List<Token> result = new LinkedList<Token>();
+        for(int index=0; index < input.length();) {
+
+            char current = input.charAt(index);
+            if(Character.isDigit(current)) {
+                int endIndex = index+1;
+                if(endIndex<input.length()) {
+                    while(Character.isDigit(input.charAt(endIndex)) && endIndex<input.length()) {
+                        endIndex += 1;
+                    }
+                }
+                Token token = new Token(TokenType.NUMBER, input.substring(index,endIndex));
+                result.add(token);
+                index += endIndex - index;
+            }
+            else if(Character.isWhitespace(current)) {
+                index++;
+            }
+            else if(Character.isLetter(current)){
+                int iterator = index;
+                while(Character.isLetter(input.charAt(iterator)) && iterator<input.length()) {
+                    Token token = new Token(TokenType.VARIABLE, String.valueOf(input.charAt(iterator)));
+                    result.add(token);
+                    iterator += 1;
+                    if(!(iterator<input.length())) {
+                        break;
+                    }
+                }
+                index += iterator - index;
+            }
+            else {
+                Token token = new Token(TokenType.SPECIAL, String.valueOf(current));
+                result.add(token);
+                index++;
+            }
+        }
 
+        return result;
+    }
 }