wordgroup.java

一個手機程序(電子詞典),一個不可多得的源碼程序,是學習J2ME的好東東.

package org.zblog.zenghelper.dbtool;

import java.util.Hashtable;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.util.Enumeration;
import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;

/**
 * <br><strong>Z英语学习助手－RMS操作工具类</strong><br>
 * <br>
 *   该类映射为RMS中词组记录，词组记录主要记录了一个Hashtabe中的数据，该Hashtable中key为
 * 词（En或Cn）的String,value为该词在词库（En库或Cn库）中Recorrd ID,该类主要用于在查询
 * 时，能快速缩小循环遍历的范围，直接定位到该词组，然后在从Hashtable中记录的id快速定位到
 * 词的详细信息．
 * <br>  其中该类中的:enBaseNum和cnBaseNum分别记录了En和Cn词组的Rs ID开始Num,因为设备不同，
 * 开始的Num可能不一样，主要是用于计算Rs id时，将固定算法的Id+baseNum，从而得出词组ID
 *
 * @author <a href="mailto:[e-mail]">朱传伟</a><br><a href="http://www.zblog.org">www.zblog.org</a></p>
 * @version <strong>ZEnHelper</strong> Ver 1.0
 */
public class WordGroup {
    private DbTool dbt=DbTool.getInstance();
    private String rsName=null;
    public int rsId=-1;
    public boolean isen=true;
    //记录中 文字符串->id 集合
    public Hashtable words=new Hashtable();
    public byte[]bytes=null;

    /**
     * 根据传递的单词，先通过固定算法定位RMS名字和RSId,然后再从RMS中获取数据，
     * 以构造WordGroup对象
     * @param word String
     */
    public WordGroup(String word){
        word=word.toLowerCase();
        if(word.charAt(0)>'z')
            init(word,false);
        else
            init(word,true);
    }

    /**
     * 直接传递RMS名字和id的方式进行初始化构造对象，该方法不再去判断单词
     * 的类型en或cn,而是直接从RMS中load数据进行构造对象
     * @param rsname String　RMS名
     * @param id int　　RSId

    public WordGroup(String rsname,int id){
        rsName=rsname;
        rsId=id;
        load();
    }
    */

    /**
     * 根据word关键字，用固定算法计算RSid，用en是否英文标志来确定RMS名字．然后从RMS中load
     * 数据来进行对象的构造
     * @param word String
     * @param en boolean
     */
    public WordGroup(String word,boolean en){
       init(word,en);
    }

    /**
     * 初始化方法，从数据库中获取byte[]数据，还原个对象的属性
     * @param word String
     * @param en boolean
     */
    private void init(String word,boolean en){
        isen=en;
        NumGenerator ng=NumGenerator.getInstance();
        rsId=ng.getWordNum(word,en);
        if(en)
            rsName=DbTool.EN_WORD_GROUP_DB;
        else
            rsName=DbTool.CN_WORD_GROUP_DB;
        load();
    }


    /**
     * 从RMS中加载字符数组来初始化对象
     * @param fw String
     */
    private void load(){
        formByte(dbt.getRSByte(rsName,rsId));
    }

    /**
     * 查询英文或中文词语，如果找到，则返回该词的RMS id,
     * 否则返回-1,表示没有找到．
     * @param word String
     * @return int
     */
    public int searchWord(String word){
        String vi=(String)words.get(word);
        if(vi!=null){
            return Integer.parseInt(vi);
        }
        return -1;
    }

    /**
     * 向词组中添加词语(英文单词或中文词语）
     * @param word String
     * @param rid int
     */
    public void addWord(String word,int rid){
        words.put(word,rid+"");
    }

    /**
     * 保存对该词组对象WordGroup的修改
     */
    public void store() throws IOException {
        toBytes();
        dbt.update(rsName,bytes,rsId);
    }

    /**
     * 将Hashtable中的值转换为byte[]，主要用于数据库存储
     * @return byte[] 返回该组别的byte[]格式
     */
    public void toBytes() throws IOException {
            try{
                ByteArrayOutputStream bos=new ByteArrayOutputStream();
                DataOutputStream dos=new DataOutputStream(bos);
                Enumeration enu=words.keys();
                Object key=null;
                Object value=null;
                dos.writeInt(words.size());
                while (enu.hasMoreElements()) {
                    key = enu.nextElement();
                    value = words.get(key);
                    dos.writeUTF((String) key);
                    dos.writeUTF((String) value);
                }
                bytes=bos.toByteArray();
                dos.close();
                bos.close();
            }catch(Exception e){
                e.printStackTrace();
            }
    }
    /**
     * 从RMS中取出byte[],并恢复原格式
     * @param data byte[]
     */
    public void formByte(byte[]data){
        bytes=data;
        if(data==null||data.length<=0){
            words.clear();
            return;
        }
        try{
            ByteArrayInputStream bis = new ByteArrayInputStream(data);
            DataInputStream dis = new DataInputStream(bis);
            int count = dis.readInt();
            words.clear();
            while(count>0){
                words.put(dis.readUTF(),dis.readUTF());
                count--;
            }
            dis.close();
            bis.close();
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }
}