KWIC系统之事件架构实现（排序模块，拆分模块，输入模块）

package kwic.es;
import java.util.Observable;
import java.util.Observer;
//排序器，将所有字符串按照字典序排序
//监听拆解后字符串集
public class Alphabetizer implements Observer{
  public void update(Observable observable, Object arg){
    LineStorageWrapper shifts = (LineStorageWrapper) observable;
    LineStorageChangeEvent event = (LineStorageChangeEvent) arg;
    //在这里由于删除后原序列中余留的行的顺序并不会改变，所以不用再添加删除情况了
    switch(event.getType()){
    case LineStorageChangeEvent.ADD:
      int count = shifts.getLineCount();
      String shift = shifts.getLineAsString(count - 1);
      for(int i = 0; i < (count - 1); i++){
        if(shift.compareTo(shifts.getLineAsString(i)) <= 0){
           shifts.insertLine(shifts.getLine(count - 1), i);
           shifts.deleteLine(count);
           break;
        }          
      }
      break;
    default:
      break;     
    }
  }
}

 

 

package kwic.es;
import java.util.Observable;
import java.util.Observer;
import java.util.ArrayList;
import java.util.StringTokenizer;
//拆分器，按规则将字符串拆分为多个字符串，将拆分后的所有字符串添加到已拆解字符串库中
//监听拆解前字符串库，也就是主程序KWIC中的lines集合
public class CircularShifter implements Observer{
  private LineStorageWrapper shifts_;
  public CircularShifter(LineStorageWrapper shifts){
    shifts_ = shifts;
  }
  @SuppressWarnings("unchecked")
  //所监听的对象发送状态改变消息时促发此方法的执行
  //方法传入促发事件源对象和事件的描述消息（即LineStorageChangeEvent对象）
public void update(Observable observable, Object arg){
    LineStorageWrapper lines = (LineStorageWrapper) observable;
    LineStorageChangeEvent event = (LineStorageChangeEvent) arg;
    //分析消息属性并作相应处理
    switch(event.getType()){
    case LineStorageChangeEvent.ADD:
      String[] line = lines.getLine(lines.getLineCount() - 1);
      for(int i = 0; i < line.length; i++){
        ArrayList words = new ArrayList();
        for(int j = i; j < (line.length + i); j++)
          words.add(line[j % line.length]);
        String[] line_rep = new String[words.size()];
        for(int k = 0; k < line_rep.length; k++)
          line_rep[k] = (String) words.get(k);
        shifts_.addLine(line_rep);
      }
      break;
      //自己添加的删除监听器
    case LineStorageChangeEvent.DELETE:
     StringTokenizer tokenizer = new StringTokenizer(event.getArg());
    if(tokenizer.countTokens() > 0){
           ArrayList words = new ArrayList();         
           while(tokenizer.hasMoreTokens())
             words.add(tokenizer.nextToken());
           String[] line1 = new String[words.size()];
           //得到一串字符串（用户输入的原始字符串）中的单词序列
           for(int i = 0; i < line1.length; i++)
             line1[i] = (String) words.get(i);
           for(int i = 0; i < line1.length; i++){
               ArrayList words1 = new ArrayList();
               for(int j = i; j < (line1.length + i); j++)
                 words1.add(line1[j % line1.length]);
               String[] line_rep = new String[words1.size()];
               for(int k = 0; k < line_rep.length; k++)
                 line_rep[k] = (String) words1.get(k);
              
               shifts_.deleteLine(line_rep);
             }
          
    }
     break;
    default:
      break;     
    }
  }
}

 

 

package kwic.es;
import java.io.BufferedReader;

import java.io.IOException;
import java.io.InputStreamReader;

import java.util.StringTokenizer;
import java.util.ArrayList;
//用户输入管理器，不断监听用户输入，分析后决定后续处理
//启动时须传输三个参数，即程序中的三个存储器：原始数据存储器，拆分排序存储器以及单词统计存储器
public class Input implements Runnable{
 private LineStorageWrapper lsw;
 public static final int ADD=0;
 public static final int DELETE=1;
 public static final int PRINT=2;
 private Output output;
 private LineStorageWrapper shifts;
 private WordStorage wordStore;
 private int type;
public void parse(LineStorageWrapper line_storage,LineStorageWrapper sh,WordStorage ws){
    this.lsw=line_storage;
    this.shifts=sh;
    this.wordStore=ws;
    output=new Output();
    new Thread(this).start();
}
//为防止用户输入读取阻塞主线程，建立用户输入读取线程，不断监听用户输入并分析
@SuppressWarnings("unchecked")
@Override
public void run() {
 System.out.print("Add,Delete,Print,Quit,Index:");
 try{
  //包装读取用户数据输入的字符流
       BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
       String line;
       //死循环，不断读取用户输入
       while((line=reader.readLine())!=null){//如果没有数据读入，而又没有到输入流结尾，则阻塞在这里
        //如果输入a，则改变状态为添加字符串状态
        if(line.equals("a")){
         type=ADD;
        }
        //如果输入d，则改变状态为删除字符串状态
        else if(line.equals("d")){
         type=DELETE;
        }
        //如果输入p，则打印处理后的字符串集合
        else if(line.equals("p")){
         type=PRINT;
         output.print(shifts);
        }
        //如果输入i则打印单词统计集中的所有单词以及单词出现的次数
        else if(line.equals("i")){
         type=PRINT;
         output.print(wordStore);
        }
        //如果输入q，则系统正常退出，即关闭虚拟机对象
        else if(line.equals("q")){
         System.exit(0);
        }
        //字符串读取机制，将字符串拆解为单词数组
        else{
         StringTokenizer tokenizer = new StringTokenizer(line);
         if(tokenizer.countTokens() > 0){
                ArrayList words = new ArrayList();         
                while(tokenizer.hasMoreTokens())
                  words.add(tokenizer.nextToken());
                String[] line_rep = new String[words.size()];
                //得到一串字符串（用户输入的原始字符串）中的单词序列
                for(int i = 0; i < line_rep.length; i++)
                  line_rep[i] = (String) words.get(i);
               // 向lines中存储得到的单词序列
                if(type==ADD)
                 lsw.addLine(line_rep);
                //从lines中删除得到的单词序列
                else if(type==DELETE){
                  lsw.deleteLine(line_rep);
                
                }
                
            }
         System.out.print("Add,Delete,Print,Quit,Index:");

        }
       
       }
 //读入错误处理
 }catch(IOException e){
  System.out.println("Input error !");
 }
}

}