wordlist.java

单词查询系统 用java实现 界面美观大方 可以进行存取 查询等功能

package support;
import java.io.*;
public class WordList {
    /*
	 * @param args
	 *本类中所有涉及到坐标的函数使用
	 */
	private Word [][][] wordbox;//3D单词存储区域
	private int [][] wordsmount;//返回2D存储数量
	public int order1,order2,order3,progress;//首和第二字母数字化
	private int bx,by,bz;//存储盒子中的三维坐标
	public int checkstore=0;//存储查询结果的临时变量
	private String path;//存储路径设置
	private Word temp;
	private File box;
	public WordList()
	{
		/*构造函数*/
		bx=60;
		by=60;
		bz=100;
		init();
	}
	public WordList(int x,int y,int z)
	{
		/*有参数的构造函数构造新的大小的存储盒子*/
		bx=x;
		by=y;
		bz=z;
		init();
	}
	public void init()
	{
		/*初始化函数*/
		wordbox=new Word[bx][by][bz];
		wordsmount=new int[bx][by];	
		temp=new Word();
		progress=0;
		for(int i=0;i<bx;i++)
			for(int j=0;j<by;j++)
				{
				wordsmount[i][j]=0;
				for(int k=0;k<bz;k++)
				{
					wordbox[i][j][k]=new Word();
					progress=((i+1)*(j+1)*(k+1)*100)/(bx*by*bz);
				}
				}
		order1=0;order2=0;order3=0;
	}
	/*属性操作设置*/
	public String getPath()
	{
		/*返回字典文件存储路径*/
		return path;
	}
    private void setWordsMount(int x,int y,int m)
    {
    	wordsmount[x][y]=m;
    }
    public void setTemp(Word w)
    {
    	/*临时单词类用于存储查询时要返回的Word*/
    	temp=w;
    }
    public int getWordsMount(int x,int y)
	{
		/*获得在盒子地面由x,y指出的那个柱形空间里已经存放的单词数量*/
		if(x>bx-1||y>by-1||x<0||y<0)
		{/*如果输入的查询坐标不合法则返回-1*/
			return -1;
		}
		return wordsmount[x][y];
	}
    public int[][] getWordsMount()
    {
    	return wordsmount;
    }
    public Word getTemp()
    {
    	return temp;
    }
	public void setWordbox(int x,int y,int z,Word w)
	{
		/*向盒子空间中指定位置添加单词*/
		wordbox[x][y][z]=w;
	}
	public Word getWordbox(int x,int y,int z)
	{
		return wordbox[x][y][z];
	}
	public Word[] getWordbox(int x,int y)
	{
		return wordbox[x][y];
	}
	/*WordBox辅助函数设置*/
	public void wordDiged(String word)
	{
		/*单词NO.1，NO.2 字母数字化*/
        /*获得NO.1&NO.2字母*/
		char[] ch=word.trim().toCharArray();
		try{order1=ch[0]-65;}catch(Exception e){}
		if(order1<0)
		{
			order1=0;
		}
		try{order2=ch[1]-65;}catch(Exception e){}
		if(order2<0)
		{
			order2=0;
		}
	}
	public int getOrder1(){return order1;}
	public int getOrder2(){return order2;}
	/*WordBox操作函数设置
	 * 1.插入操作
	 * 2.删除操作
	 * 3.查询操作
	 * 4.Load
	 * 5.Save*/
	public int InsertWord(Word w)
	{
		/*1.插入单词操作*/
		order3=0;//将计数器清零
		if(w.getEngWord().equals(""))
		{/*如果插入的是空单词，那么返回-1*/
			return -1;
		}
		if(this.CheckTheWord(w)==1)
		{/*如果已经有这个词那么拒绝添加*/
			return -1;
		}
		/*如果确定单词不为空那么即开始进行单词数字化工作并开始插入*/
	    this.wordDiged(w.getEngWord());
	    /*查询该柱形空间内有多少个单词*/
	    order3=this.getWordsMount(order1,order2);
	    if(order3>bz-1)
	    	{
	    	return -1;//如果空间已满则阻止加入新词
	    	}
	    /*将单词插入*/
	    order3+=1;
	    this.setWordsMount(order1,order2,order3);
	    this.setWordbox(order1,order2,order3,w);
		return 1;
	}
	public int CheckTheWord(Word w)
	{
		order3=0;
		if(w.getEngWord().equals(""))
		{/*如果插入的是空单词，那么返回-1*/
			//return -1;
		}
		/*如果确定单词不为空那么即开始进行单词数字化工作并开始插入*/
	    this.wordDiged(w.getEngWord());
	    order3=this.getWordsMount(order1,order2);
	    int i=0;
	    while(!this.getWordbox(order1,order2,i).getEngWord().equals(w.getEngWord())
	    		&&i<order3+1)
	    {
	    	/*当循环结束时如果i=order3那么证明该循环没有找到单词*/
	    	i+=1;
	    }
	    if(i==order3+1)
	    {
	    	//如果i满足上述条件证明没有找到单词
	    	return -1;
	    }
	    /*将临时单词类设为找到的单词*/
	    checkstore=i;
	    w.setTimes(w.getTimes()+1);//查询完毕增加一次查询次数纪录
	    this.setTemp(this.getWordbox(order1,order2,i));
		return 1;
	}
	public int  DeleteWord(Word w)
	{/* 3.删除操作*/
		int i=this.CheckTheWord(w);
	    this.wordDiged(w.getEngWord());
	    Word temp2=new Word();//建立空类
		if(i==-1)
		{
			return -1;
		}
		for(int j=checkstore;j<this.getWordsMount(order1,order2);j++)
		{
			/*使用线性表的方法来实现删除单词操作*/
			this.setWordbox(order1,order2,j,this.getWordbox(order1,order2,j+1));
		}
		this.setWordbox(order1,order2,this.getWordsMount(order1,order2),temp2);
		this.setWordsMount(order1,order2,this.getWordsMount(order1,order2)-1);
		return 1;
	}	
	public void Load(String p)
	{
		/*读取字典文件
		 * 需要读取的信息:
		 * 1. 每个柱形空间内存储的单词数量
		 * 2. 每个单词类及其各个属性
		 */
		box=new File(p);
		path=p;
		String tempstr="";//临时字符串用于读取字典文件
		int length1=0,length2=0;
		try{
			DataInputStream din=new DataInputStream(new FileInputStream(box));
			for(int i=0;i<bx;i++)
				for(int j=0;j<by;j++)
				{
					wordsmount[i][j]=din.readInt();
					if(wordsmount[i][j]!=0)
					{
						System.out.println("wordsmount["+i+"]["+j+"]="+wordsmount[i][j]+"\t");
					}
					for(int k=1;k<wordsmount[i][j]+1;k++)
					{
						/*优化读取方法只读有意义的单词，节省时间*/
						/*读取英文属性*/
						wordbox[i][j][k].setTimes(din.readInt());
						length1=din.readInt();
						length2=din.readInt();
						for(int r=0;r<length1;r++)
						{
							tempstr+=din.readChar();
						}
						wordbox[i][j][k].setEngWord(tempstr);tempstr="";
						for(int f=0;f<length2;f++)
						{
							tempstr+=din.readChar();
						}
						wordbox[i][j][k].setChWord(tempstr);
						tempstr="";//字符读取计数器清零
					    /*读取进度显示部分*/
					    progress=((i+1)*(j+1)*(k+1)*100)/(bx*by*bz);
					}
				}
			
			din.close();
			}catch(Exception e){/*暂时不做任何处理*/}
	}
	public void Save(String p)
	{
		/*存储字典文件
		 * 需要存储的信息:
		 * 1. 每个柱形空间内存储的单词数量
		 * 2. 每个单词类及其各个属性
		 */
		box=new File (p);
		path=p;
		try{
			DataOutputStream dout=new DataOutputStream(new FileOutputStream(box));
			for(int i=0;i<bx;i++)
				for(int j=0;j<by;j++)
				{
					dout.writeInt(wordsmount[i][j]);
					if(wordsmount[i][j]!=0)
					{
						System.out.println("wordsmount["+i+"]["+j+"]="+wordsmount[i][j]+"\t");
					}
					for(int k=1;k<wordsmount[i][j]+1;k++)
					{
					/*优化存储方案：字典大小算法改变前：4.13mb，改变后15kb*/
						if(wordbox[i][j][k].getEngWord().equals(""))
						{
							/*首先进行判断该单词是否有意义，若否则不进行存储*/
							continue;
						}else{
						dout.writeInt(wordbox[i][j][k].getTimes());
						dout.writeInt(wordbox[i][j][k].getEngLength());
						dout.writeInt(wordbox[i][j][k].getChLength());
						dout.writeChars(wordbox[i][j][k].getEngWord());
						dout.writeChars(wordbox[i][j][k].getChWord());}
					    /*进度显示部分*/
					    progress=((i+1)*(j+1)*(k+1)*100)/(bx*by*bz);
					}
				}
			dout.close();			
		}catch(Exception e){/*暂时不做任何处理*/}
	}
}