获得字符串的拼音头和全拼的写法

public class SpellCache implements java.io.Serializable
{
private static final long serialVersionUID = -8208755962314651055L;
private static SpellCache obj_SpellCache;

static ArrayList<Spell> arr_Spell = null;

/**
* 实例初始化
*/
private SpellCache()
{
try
{
if(obj_SpellCache==null)
init();
}
catch(Exception e)
{
e.printStackTrace();
obj_SpellCache = null;
}
}

/**
* 获得拼音缓存的实例
* @return 拼音缓存的实例
*/
public static synchronized SpellCache getInstance()
{
if(obj_SpellCache == null)
{
obj_SpellCache = new SpellCache();
}

return obj_SpellCache;
}

/**
* 拼音缓存内容的初始化
*/
private void init() throws Exception
{
DBConnection dbc = new DBConnection();
ResultSet rst = null;
try
{
/// 查询出拼音内容
String str_SQL = Common.SELECT + Field.WORD + Common.COMMA +
Field.SPELL + Common.COMMA +
Field.ASPELL +
Common.S_FROM + Table.SPELL +
Common.S_ORDER + Field.WORD;

/// 查询
rst = dbc.excuteQuery(str_SQL);

/// 初始化 arr_Spell
arr_Spell = new ArrayList<Spell>();

while(rst.next())
{
char chr_Word = rst.getString(Field.WORD).charAt(0);
char chr_Spell = rst.getString(Field.SPELL).charAt(0);
String str_ASpell = rst.getString(Field.ASPELL);

arr_Spell.add(new Spell(chr_Word, chr_Spell, str_ASpell));
}

rst.close();

System.out.println("缓存中已载入" + arr_Spell.size() + "个拼音");
}
catch(Exception e)
{
throw new Exception(e.getMessage());
}
finally
{
rst.close();
dbc.freeConnection();
}
}

/**
* 获得拼音的总数
* @return int 拼音的总数
*/
public synchronized int getCount()
{
return arr_Spell.size();
}

/**
* 获得单个拼音对象
* @param chrWord 字符
* @return Spell 单个拼音缓存对象
*/
public Spell getObject(char chrWord)
{
Iterator it = arr_Spell.iterator();

while(it.hasNext())
{
Spell obj_Spell = (Spell)it.next();

if (obj_Spell.equals(chrWord)) return obj_Spell;
}
return null;
}

/**
* 获得字符的拼音头
* @param chrWord 字符
* @return String 拼音头
*/
public String getSpell(char chrWord)
{
Spell obj_Spell = getObject(chrWord);

if(obj_Spell==null) return null;

return String.valueOf(obj_Spell.getSpell());
}

/**
* 获得字符的全拼
* @param chrWord 字符
* @return String 全拼
*/
public String getASpell(char chrWord)
{
Spell obj_Spell = getObject(chrWord);

if(obj_Spell==null) return null;

return String.valueOf(obj_Spell.getASpell());
}

/**
* 获得字符串的拼音头
* @param strWord 字符串
* @return String 拼音头
*/
public String getSpell(String strWord)
{
if(strWord==null) return null;
if(strWord.equals("")) return null;

char[] chr_Single = strWord.toCharArray();

String str_Spell = "";

for(int i=0; i<chr_Single.length; i++)
{
str_Spell += getSpell(chr_Single[i]);
}

return str_Spell;
}

/**
* 获得字符串的全拼
* @param strWord 字符串
* @return String 全拼
*/
public String getASpell(String strWord)
{
if(strWord==null) return null;
if(strWord.equals("")) return null;

char[] chr_Single = strWord.toCharArray();

String str_ASpell = "";

for(int i=0; i<chr_Single.length; i++)
{
str_ASpell += getASpell(chr_Single[i]);
}

return str_ASpell;
}

/**
* 更新拼音
* @param chrWord 字符
* @param chrSpell 拼音头
* @param strASpell 全拼
*/
public synchronized void update(char chrWord,
char chrSpell,
String strASpell) throws Exception
{
update(new Spell(chrWord, chrSpell, strASpell));
return;
}

/**
* 更新拼音
* @param objSpell 单个拼音对象
*/
public synchronized void update(Spell objSpell) throws Exception
{
try
{
Spell obj_Spell = getObject(objSpell.getWord());

DataStorage obj_DS = new DataStorage();

/// 拼音缓存存在，更新
if (obj_Spell!=null)
{
obj_Spell.setSpell(objSpell.getSpell());
obj_Spell.setASpell(objSpell.getASpell());

String str_Spell = String.valueOf(objSpell.getSpell());
String str_ASpell = String.valueOf(objSpell.getASpell());
String str_Word = String.valueOf(objSpell.getWord());

String str_SQL = Common.UPDATE + Table.SPELL +
Common.S_SET + Field.SPELL + Common.EQUAL + General.addQuotes(str_Spell) + Common.COMMA +
Field.ASPELL + Common.EQUAL + General.addQuotes(str_ASpell) +
Common.S_WHERE + Field.WORD + Common.EQUAL + General.addQuotes(str_Word);

obj_DS.addSQL(str_SQL);
obj_DS.runSQL();
}

/// 拼音缓存不存在，添加
else
{
arr_Spell.add(objSpell);

String str_SQL = Common.INSERT + Table.SPELL +
General.addBracket(Field.WORD + Common.COMMA +
Field.SPELL + Common.COMMA +
Field.ASPELL) +
Common.S_VALUES +
General.addBracket(General.addQuotes(String.valueOf(objSpell.getWord())) + Common.COMMA +
General.addQuotes(String.valueOf(objSpell.getSpell())) + Common.COMMA +
General.addQuotes(objSpell.getASpell()));

obj_DS.addSQL(str_SQL);
obj_DS.runSQL();
}

return;
}
catch(Exception e)
{
throw new Exception(e.getMessage());
}
}

}
class Spell implements java.io.Serializable
{
private static final long serialVersionUID = 8537233176930218357L;
private char m_chr_Word;
private char m_chr_Spell;
private String m_str_ASpell;

public Spell()
{
}

public Spell(char chrWord, char chrSpell, String strASpell)
{
m_chr_Word = chrWord;
m_chr_Spell = chrSpell;
m_str_ASpell = strASpell;
}

public String getASpell()
{
return m_str_ASpell;
}

public void setASpell(String strASpell)
{
m_str_ASpell = strASpell;
}

public char getSpell()
{
return m_chr_Spell;
}

public void setSpell(char chrSpell)
{
m_chr_Spell = chrSpell;
}

public char getWord()
{
return m_chr_Word;
}

public void setWord(char chrWord)
{
m_chr_Word = chrWord;
}

public boolean equals(char chrValue)
{
if(m_chr_Word==chrValue) return true;
return false;
}
}