[JAVA] Implémentons Lexer (2)

Préface

Peut-être que cela fonctionne dans l'environnement ci-dessus.

Article précédent [Implémentons Lexer (1)] (https://qiita.com/mirror11akii/items/7fe6fd3143b9a1eb9683)

Supplément

Cette série est ** écrite avec le désir de se connecter avec des personnes qui sympathisent avec moi, des personnes intéressées par un nouveau langage et des programmeurs Java qui souhaitent développer des équipes **. Bien sûr, vous pouvez utiliser et parcourir à d'autres fins. Cependant, je serais très heureux si cela vous intéressait, et il serait très utile que vous me disiez quelque chose dans les commentaires.

J'ai l'intention de rendre Lexer un peu fonctionnel. Comme Lexer, j'ai senti que c'était difficile à gérer si le nombre d'entrées et de sorties était différent et le nombre de sorties n'était pas connu.

la mise en oeuvre

FLexer.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;

public class FLexer {

    static Stack<String> stack = new Stack();

    //private static List<Character> brackets = Arrays.asList('(',')','{','}','[',']');
    private static List<Character> operators = Arrays.asList('=','+','-','*','/');

    public static FType getType(final Character c){
        if(Character.isLetter(c)) return FType.alphabet;
        else if(Character.isDigit(c)) return FType.digit;
        else if(Character.isWhitespace(c)) return FType.space;
        else if(operators.contains(c)) return FType.operator;
        //else if(brackets.contains(c)) return FType.brackets;
        return FType.other;
    }
    public static List<Character> toList(final char[] chars){
        List<Character> list = new ArrayList<>();
        for(Character aChar : chars){
            list.add(aChar);
        }
        return list;
    }
    public static void analyze(final Character aChar){
        if(stack.empty()){
            stack.push(Character.toString(aChar));
        }else{
            final String previous = stack.pop();
            if(getType(aChar) == getType(previous.charAt(0))){
                stack.push(previous + aChar);
            }else{
                stack.push(previous);
                stack.push(Character.toString(aChar));
            }
        }
    }
    public static void disp(){
        System.out.println(stack);
    }
}

FType.java

public enum FType{
    alphabet,
    digit,
    space,
    operator,
    //bracket,
    other
}

Description de la mise en œuvre

Je n'ai pas implémenté de "parenthèses" parce que c'est gênant, mais je pense que cela peut être géré en augmentant la branche if de analy ().

public static List<Character> toList(...) Je voulais utiliser une expression lambda, j'ai donc préparé une fonction pour la convertir en liste. public static void analyze(...) Je pensais que si je lisais l'élément précédent, je pourrais l'utiliser comme une pile, alors je l'ai fait une pile.

Courir

Main.java

import java.io.IOException;

public class Main{
    public static void main(String[] args) throws IOException{
        System.out.println("\n--EAM");
        char[] chars = EAM.use("lib\\test.txt", eam -> eam.read());
        for (char aChar : chars) {
            System.out.print(aChar);
        }
        System.out.println( "\n--FLexer");
        FLexer.toList(chars).stream()
                            .forEach(FLexer::analyze);
        FLexer.disp();
    }
}

--EAM
close()
a = 2 + 7 * 3
log a
--FLexer
[a,  , =,  , 2,  , +,  , 7,  , *,  , 3, 
, log,  , a]

Si ça ressemble à ça, c'est un succès. Si vous avez des questions, n'hésitez pas à demander.