How to implement a FSM – Finite State Machine in Java

I have something to do for work and I need your help. We want to implement a FSM - Finite State Machine, to identify char sequence(like: A, B, C, A, C), and tell if it accepted.

We think to implement three classes: State, Event and Machine. The state class presents a node in the FSM, we thought to implement it with State design pattern, every node will extend from the abstract class state and every class would handle different types of events and indicate transitions to a new state. Is it good idea in your opinion?

Second thing, we don’t know how to save all the transitions. Again we thought to implement it with some kind of map, that hold the starting point and gets some kind of vector with the next states, but I’m not sure thats a good idea.

I would be happy to get some ideas of how to implement it or maybe you can give me some starting points.

How should I save the FSM, meaning how should I build the tree at the beginning of the program? I googled it and found a lot of examples but nothing that helps me.

Thanks a lot.


The heart of a state machine is the transition table, which takes a state and a symbol (what you’re calling an event) to a new state. That’s just a two-index array of states. For sanity and type safety, declare the states and symbols as enumerations. I always add a “length” member in some way (language-specific) for checking array bounds. When I’ve hand-coded FSM’s, I format the code in row and column format with whitespace fiddling. The other elements of a state machine are the initial state and the set of accepting states. The most direct implementation of the set of accepting states is an array of booleans indexed by the states. In Java, however, enumerations are classes, and you can specify an argument “accepting” in the declaration for each enumerated value and initialize it in the constructor for the enumeration.

For the machine type, you can write it as a generic class. It would take two type arguments, one for the states and one for the symbols, an array argument for the transition table, a single state for the initial. The only other detail (though it’s critical) is that you have to call Enum.ordinal() to get an integer suitable for indexing the transition array, since you there’s no syntax for directly declaring an array with a enumeration index (though there ought to be).

To preempt one issue, EnumMap won’t work for the transition table, because the key required is a pair of enumeration values, not a single one.

enum State {
    Initial( false ),
    Final( true ),
    Error( false );
    static public final Integer length = 1 + Error.ordinal();

    final boolean accepting;

    State( boolean accepting ) {
        this.accepting = accepting;

enum Symbol {
    A, B, C;
    static public final Integer length = 1 + C.ordinal();

State transition[][] = {
    //  A               B               C
        State.Initial,  State.Final,    State.Error
    }, {
        State.Final,    State.Initial,  State.Error

Leave a Reply

Your email address will not be published. Required fields are marked *