数据快速查询的新方法

/**//*
 * Main.java
 *
 * Created on 2006年11月20日, 下午4:29
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package chartest;
/** *//**
 *
 * @author longronglin
 */
import java.util.Random;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.BufferedWriter;
import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;

public class Main
...{
    private static final int Max = 10019;
    
    private static String[] keyWord = new String[Max];
    
    private static long[] keyNum = new long[Max];
    
    private static String charsetName = "gbk";

    /** *//** Creates a new instance of Main */
    public Main()
    ...{
    }

    /** *//**
     * @param args the command line arguments
     */
    
    public static void main(String[] args) 
    ...{
        /** *//** 关键词文件 */
        String keyWordFile = "d:/keyword.txt";
        
        /** *//** 读取关键词 并存入keyWord数组中 */
        readKeyWord(keyWordFile);
        
        /** *//** 关键词文件对应的前8位字节的long型数 */
        String keyNumFile = "d:/keywordNum.txt";
        
        /** *//** 读取对应的数 并存入keyNum数组中 */
        readKeyNum(keyNumFile);

        /** *//** 根据keyWordFile中的关键词算出每个词的前8位字节对应的long数据 并存入keyNumfile文件中 */
        //writeNumFile(keyWordFile,keyNumFile);
        int i = 0;
        
        /** *//** 对字符串进行顺序查找 */
        long startTime = System.currentTimeMillis();
        for(i=0;i<keyWord.length-3;i++)
        ...{
            /** *//** 字符串对应的首次出现的序号 */
            keyWordSearch(keyWord[i]);
            long endTime = System.currentTimeMillis();
            System.out.println(endTime-startTime);
        }

            
        System.out.println("The first end");
        /** *//** 对keyNum数组进行排序从小到大 */
        Arrays.sort(keyNum);
                
        startTime = System.currentTimeMillis();
        
        for(i=0;i<keyWord.length-3;i++)
        ...{
            int len = 0;
            /** *//** 字符串对应的首次出现的序号 */
            try
            ...{
                len = keyWord[i].getBytes(charsetName).length;
            }
            catch(Exception e)
            ...{
                e.getStackTrace();
            }
            
            if(len <= 8)
            ...{
                keyNumSearch(keyWord[i]);
            }
            else
            ...{
                keyWordSearch(keyWord[i]);
            }
            
            long endTime = System.currentTimeMillis();
            System.out.println(endTime-startTime); 
        }
       

        }
     public static void readKeyWord(String fileName)
     ...{
        int i = 0;
        try 
        ...{
            BufferedReader in = new BufferedReader(new FileReader(fileName));       
            String strTemp = null;
            while ((strTemp = in.readLine()) != null) 
            ...{
                keyWord[i]=strTemp;
                i++;
             }
            in.close();
        } 
        catch (IOException e) 
        ...{
            e.getStackTrace();
        }
     }
     
     public static void readKeyNum(String fileName)
     ...{
        int i = 0;
        try 
        ...{
            BufferedReader in = new BufferedReader(new FileReader(fileName));       
            String strTemp = null;
            while ((strTemp = in.readLine()) != null) 
            ...{
                keyNum[i]=Long.parseLong(strTemp);
                i++;
             }
            in.close();
        } 
        catch (IOException e) 
        ...{
            e.getStackTrace();
        }
     }
     
  
     public static final long getLongOfByteArray (byte[] bytes)
    ...{ 
        long result = 0;
        int len =0;
        
        if(bytes.length<8)
        ...{
            len = bytes.length;
        }
        else
        ...{
            len = 8;
        }
        
        for (int i=0; i<len ; i++) 
        ...{ 
            result=result<<8;   
            result=result+(bytes[i]&0xff);
        } 
        
        return result;
    } 

    public static long keyWordSearch(String str)
    ...{       
        int result=0;
        
        for(int i=0; i<keyWord.length; i++)
        ...{
            if(str.equals(keyWord[i]))
            ...{              
                result = i;
                //System.out.println(i);
                return(i);
            }

        }
               
        return -(result+1);
    }
    
    public static long keyNumSearch(String str)
    ...{
        byte[] strByte = null;
        long result = 0;
        
        try
        ...{
            strByte = str.getBytes(charsetName);
        }
        catch(Exception e)
        ...{
           e.getStackTrace();
        }

        long keyWordNum = getLongOfByteArray(strByte);

        long index = Arrays.binarySearch(keyNum,keyWordNum);
                     
        if(index>0)
        ...{
            return index; 
        }
        
        return -(result+1);
    }
    
    public static void writeNumFile(String srcFile,String dstFile)
    ...{
        File SrcFile=new File(srcFile);
        
        if(!SrcFile.exists())
        ...{ 
            System.err.println("Can't Find " + srcFile);
        }

        try 
        ...{
            BufferedReader in = new BufferedReader(new FileReader(SrcFile));
            BufferedWriter out = new BufferedWriter(new FileWriter(dstFile));
            String str = null;

            while ((str = in.readLine()) != null) 
            ...{
                try 
                ...{              
                    out.write(String.valueOf(getLongOfByteArray(str.getBytes(charsetName))));
                    out.newLine();
                }
                catch (IOException e)
                ...{
                }
            }

            in.close();
            out.close();
        } 
        catch (IOException e) 
        ...{
            e.getStackTrace();
        }
    }
    
    
}