1，需要先将要被查找的文字通过structure方法按照拼音构建成一棵树，每个匹配节点上装有查找目标对象。

2，完成的功能：用户在输入框里输入拼音或者汉字，输入内容转化成拼音，然后按照拼音遍历树，找到结果。

3，用到了开元包pinyin4j

4，没有考虑多音字。可以按需要对多音字做多路径存储。子节点可以优化成map结构，优化遍历速度。

package com.test.common.utils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * Trie字典树类，节点用内部类Node表示，提供构建树、插入节点、搜索、等方法。
 * 需要优化的地方：1，多音字，2子节点的存储结构和查找
 * @author yfchenlei
 * @date 2012-9-12
 */
public class Trie<T> implements Serializable{
    private static final long serialVersionUID = 5694541776693908755L;
    /**
     * 根节点
     */
    private Node<T> root;
    /**
     * 最大搜索结果个数
     */
    private int maxResult = 10;
    /**
     *  默认构造方法
     */
    public Trie(){
        
    }
    /**
     * 带参构造方法
     * @param maxResult 最大搜索结果个数
     */
    public Trie(int maxResult){
        this.maxResult = maxResult;
    }
    /**
     * 根据传入数据集合构建一颗字典树
     * @param words 数据集合
     */
    public void structure(Map<String, T> items){
        root = new Node<T>('0');
        if(items == null){
            return;
        }
        Iterator<String> it = items.keySet().iterator();
        while(it.hasNext()){
            String key = it.next();
            T value= items.get(key);
            if(value != null){
                insert(key, value);
            }
        }
    }
    /**
     * 向字典树插入一个数据，word。
     * @author yfchenlei
     * @date 2012-9-12
     * @param word 要插入到字典树的数据
     */
    public void insert(String word,T item){
        String pinyin = PinYin.cn2Pinyin(word);
        if(root == null){
            root = new Node<T>('0');
        }
        Node<T> curNode = root;
        int wordLength = pinyin.length();
        for(int i = 0; i< wordLength; i++){
            char value = pinyin.charAt(i);
            Node<T> nextNode = curNode.getChild(value);
            if(nextNode == null){
                nextNode = new Node<T>(value);
                curNode.addChild(nextNode);
            }
            curNode = nextNode;
        }
        curNode.addItem(item);
    }
    /**
     * 根据输入的word的拼音，查找符合这个拼音前缀的所有集合，但不超过最大结果个数。
     * @author yfchenlei
     * @date 2012-9-12
     * @param word 根据这个数据进行查找
     * @return 符合条件的集合
     */
    public List<T> find(String word){
        List<T> result = new ArrayList<T>(maxResult);
        if(root == null || word == null){
            return result;
        }
        String pinyin = PinYin.cn2Pinyin(word);
        Node<T> curNode = root;
        for(int i = 0; i < pinyin.length(); i++){
            Node<T> child = curNode.getChild(pinyin.charAt(i));
            if(child != null){
                curNode = child;
            }else{
                return result;
            }
        }
        result = traverse(curNode, result);
        return result;
    }
    /**
     * 遍历字典树的递归方法，每次递归，将结果积累到result参数。
     * @author yfchenlei
     * @date 2012-9-12
     * @param node 当前节点
     * @param result 结果集合
     * @return 返回最后的集合
     */
    private List<T> traverse(Node<T> node, List<T> result){
        if(node == null || result.size() == maxResult){
            return result;
        }
        List<T> items = node.getItems();
        if(items != null){
            if(result.size() + items.size() > maxResult){
                for(int i = 0; i < maxResult - result.size(); i++){
                    result.add(items.get(i));
                }
            }else{
                result.addAll(node.getItems());
            }
        }
        Node<T>[] children = node.getChildren();
        if(children != null){
            for(int i = 0; i < children.length; i++){
                if(result.size() == maxResult){
                    break;
                }
                traverse(children[i], result);
            }
        }
        return result;
    }

    /**
     * trie的子类，表示树节点
     * @author yfchenlei
     * @date 2012-9-12
     */
    @SuppressWarnings("hiding")
    class Node<T> implements Serializable{
        private static final long serialVersionUID = -7145041421696945423L;
        /**
         * 节点的路径值
         */
        private char value;
        /**
         * 子节点集合
         */
        private Node<T>[] children;
        /**
         * 节点中的值集合，因为拼音可能重复，所以是集合。
         */
        private List<T> items;
    
        public Node(char value){
            this.value = value;
        }
        
        public void addItem(T item){
            if(items == null){
                items = new ArrayList<T>(1);
            }
            items.add(item);
        }
        
        public void addChild(Node<T> node){
            if(children == null){
                this.children = new Node[26];
            }
            children[node.getValue() - 'a'] = node;
        }
        
        public Node<T> getChild(char value){
            int pos = value - 'a';
            if(children == null){
                return null;
            }
            return children[pos];
        }
        
        public char getValue() {
            return value;
        }

        public Node<T>[] getChildren() {
            return children;
        }
        
        public List<T> getItems() {
            return items;
        }
    }
}

 用到的转化拼音工具：

package com.test.common.utils;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
/**
 * 汉字转拼音支持工具
 * @author yfchenlei
 * @date 2012-9-13
 */
public class PinYin {
    private static HanyuPinyinOutputFormat defaultFormat;
    
    static{
        defaultFormat = new HanyuPinyinOutputFormat(); 
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE); 
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
    }
    
    public static String cn2Pinyin(String cn){
        StringBuffer result = new StringBuffer();
        char[] chars = cn.toCharArray();
        try {
            for(int i = 0; i < chars.length; i++){
            	if(chars[i] > 128){
            		String[] pinyin = PinyinHelper.toHanyuPinyinStringArray(chars[i], defaultFormat);
        			result.append(pinyin[0]);
            	}else{
            		char letter = Character.toLowerCase(chars[i]);
            		if(letter >= 98 && letter <= 122)
            		result.append(chars[i]);
        		}
            }
        } catch (BadHanyuPinyinOutputFormatCombination e) {
            e.printStackTrace();
            return null;
        }
        return result.toString();
    }
}

。