例如，我们给定：

1. S＝{s0, s1, s2, s3, s4}
2. Sigma={a, b}
3. 状态迁移函数T，且T(s0, a} = {s1}, T(s1, a) = {s2}, T(s2, b) = {s3}, T(s3, b) = {s4}
4. s0为开始状态
5. {s4}为接受状态

NFA是一个识别器，例如图1所示的NFA，我们从状态s0开始，按顺序输入aabb，在输入第一个符号a之后，状态将从s0迁移到s1，输入第二个符号a之后，状态迁移到s2，输入第三个符号b之后，状态迁移到s3，输入第四个符号b之后，状态迁移到s4，而s4是接收状态，也就是说对我们刚才输入的aabb字符串说yes，表明本NFA识别了所输入的字符串。

所谓非确定，是指在某个状态输入同一个符号，状态可以迁移到不同的下一个状态，例如图2，在s0处输入字符a，状态既可以迁移为s1，也可以迁移为s3，准确的说是状态迁移到了{s1,s3}，因此图2所示的NFA能够接受的字符串包括aa和ab。

另外，NFA的特点还在于空符号也能进行状态迁移，例如图3的s0，不需要任何输入字符就可以迁移到s1，因此图3的NFA可以识别的语言为*a*b，即0到任意多个a，接着0到任意多个b。

NFA可以识别的语言与正则表达式所表达的语言是等价的，参考
http://en.wikipedia.org/wiki/Nondeterministic_finite_automaton

那么，NFA如何实现呢？我们先来看看NFA状态节点的一种实现：

/*

    This file is one of the component a Context-free Grammar Parser Generator,

    which accept a piece of text as the input, and generates a parser

    for the inputted context-free grammar.

    Copyright (C) 2013, Junbiao Pan (Email: panjunbiao@gmail.com)

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

package automata;

import java.util.*;

public class NFAState implements Comparable<NFAState> {

    private static int COUNT = 0;

    //状态标识，每个NFA状态节点都有唯一的数值标识

    private int id;

    public int getId() { return this.id; }

    //在创建NFA状态对象的时候，通过静态变量生成唯一标识

    public NFAState() {

        this.id = COUNT ++;

    }

    //迁移函数，由于迁移函数需要两个输入：当前状态和输入符号，因此在一个状态对象内部，

    //迁移函数都是针对本对象的，只需要输入符号就可以了，这里通过Map接口实现迁移函数

    protected Map<Integer, Set<NFAState>> transition = new HashMap<Integer, Set<NFAState>>();

    public Map<Integer, Set<NFAState>> getTransition() { return this.transition; }

    //空字符迁移函数，即从当前节点经过空字符输入所能够到达的下一个状态节点

    protected Set<NFAState> epsilonTransition = new HashSet<NFAState>();

    public Set<NFAState> getEpsilonTransition() { return this.epsilonTransition; }

    //向迁移函数添加一个映射，不给定下一个状态节点

    public NFAState addTransit(int input) {

        return addTransit(input, new NFAState());

    }

    //向迁移函数添加一个映射，给定下一个状态节点

    public NFAState addTransit(int input, NFAState next) {

        Set<NFAState> states = this.transition.get(input);

        if (states == null) {

            states = new HashSet<NFAState>();

            this.transition.put(input, states);

        }

        states.add(next);

        return next;

    }

    //向迁移函数添加一个映射，不给定下一个状态节点

    public NFAState addTransit(char input) {

        return addTransit(input, new NFAState());

    }

    //向迁移函数添加一个映射，给定下一个状态节点

    //假定我们的上下文无关文法是大小写不敏感的，当输入字符是char类型并且是字母时，

    //生成大写字母和小写字母两个映射

    public NFAState addTransit(char input, NFAState next) {

        if (Character.isLetter(input)) {

            this.addTransit((int) (Character.toUpperCase(input)), next);

            this.addTransit((int)(Character.toLowerCase(input)), next);

            return next;

        }

        this.addTransit((int)input, next);

        return next;

    }

    //添加一个空字符的映射

    public NFAState addTransit(NFAState next) {

        this.epsilonTransition.add(next);

        return next;

    }

    //返回迁移函数

    public Set<NFAState> getTransition(int input) {

        return this.transition.get(input);

    }

}

再来看看NFA的实现：

/*

    This file is one of the component a Context-free Grammar Parser Generator,

    which accept a piece of text as the input, and generates a parser

    for the inputted context-free grammar.

    Copyright (C) 2013, Junbiao Pan (Email: panjunbiao@gmail.com)

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

package automata;

import java.util.*;

import abnf.CharVal;

import abnf.NumVal;

import abnf.AbnfParser;

import abnf.RangedNumVal;

import abnf.Repeat;

import abnf.Repetition;

import abnf.Rule;

import abnf.RuleName;

public class NFA {

    //开始状态startState

    private NFAState startState = null;

    public NFAState getStartState() { return startState; }

    //接收状态acceptingStates

    private Set<NFAState> acceptingStates = new HashSet<NFAState>();

    public Set<NFAState> getAcceptingStates() { return acceptingStates; }

    public boolean accept(NFAState state) {

        return this.acceptingStates.contains(state);

    }

    public void addAcceptingState(NFAState state) {

        this.acceptingStates.add(state);

    }

    public NFA() {

        this(new NFAState(), new NFAState());

    }

    public NFA(NFAState startState) {

        this(startState, new NFAState());

    }

    public NFA(NFAState startState, NFAState acceptingState) {

        this.startState = startState;

        this.addAcceptingState(acceptingState);

    }

    //在上面的NFAState类实现中，新的状态节点是在添加迁移映射的过程中生成的，

    //这个过程中NFA并没有介入，因此NFA类不能直接得到状态集S的成员

    //而是需要从状态startState开始，不断迭代找出所有的状态节点

    protected void getStateSet(NFAState current, Set<NFAState> states) {

        if (states.contains(current)) return;

        states.add(current);

        Iterator<NFAState> it;

        it = current.getNextStates().iterator();

        while (it.hasNext()) {

            this.getStateSet(it.next(), states);

        }

        it = current.getEpsilonTransition().iterator();

        while (it.hasNext()) {

            this.getStateSet(it.next(), states);

        }

    }

    public Set<NFAState> getStateSet() {

        Set<NFAState> states = new HashSet<NFAState>();

        this.getStateSet(this.getStartState(), states);

        return states;

    }

}

这样，我们可以从NFA类中获得一个NFA的开始状态startState和接受状态集合acceptingStates，在每一个状态节点NFAState中可以获得状态迁移函数，因此NFA所定义的各个元素都实现了。