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();
}
}
。