软件体系结构KWIC实验(3)

} catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); }

BufferedWriter bw=new BufferedWriter(fw);

for(int i=0;i

try {

bw.write(ls.get(i)); bw.newLine(); } catch (IOException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

} try {

bw.close();

} catch (IOException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

} }

//Alphabetizer.java import

java.util.ArrayList; import java.util.Arrays; public class Alphabetizer { public ArrayList ls; public Alphabetizer(ArrayList ls){ this.ls=ls; }

public void alpha(){

String[] tmpArray = new String[ls.size()]; ls.toArray(tmpArray);

Arrays.sort(tmpArray); for(int

i=0;i

//CircularShifter.java import

java.util.ArrayList; public class

CircularShifter { public ArrayList ls; public CircularShifter(ArrayList ls){ this.ls=ls; }

public void shift(){

ArrayList shiftedLineIndexes=new ArrayList(); for(int i=0;i

String orinLine=ls.get(i); String sarray[]=orinLine.split(\for(int j=0;j1){ if(j==sarray.length-1){ for(int k=0;k<(sarray.length-1);k++){

newLine=newLine+\ }

}

else{

for(int k=j+1;k

for(int m=0;m

shiftedLineIndexes.add(newLine); } }

ls=shiftedLineIndexes; } }

//Main.java import

java.util.ArrayList; public class Main {

public static void main(String[] args) { // TODO Auto-generated method stub

ArrayListls=new ArrayList();

InputStore inputStore=new InputStore(ls); inputStore.input(\

CircularShifter cs=new CircularShifter(ls); cs.shift();

Alphabetizer alp=new Alphabetizer(cs.ls); alp.alpha();

Output output=new Output(alp.ls); output.output(\ } }

KWIC 基于管道过滤器风格的JAVA 语言实现

//Main类 package kwic_pipe; import java.io.File; import java.util.Scanner;

public class Main { public static void

main(String[] args) { File infile = new File(\

File outfile = new File(\ Scanner inputfile; Scanner outputfile;

try{ inputfile = new

Scanner(infile); outputfile = new Scanner(outfile); // 定义三个管道

Pipe pipe1 = new Pipe(); Pipe pipe2 = new Pipe(); Pipe pipe3 = new Pipe(); // 定义四种过滤器

Input input = new Input(infile, pipe1); Shift shift = new Shift(pipe1, pipe2);

Output output = new Output(pipe3, outfile); // 启动四种过滤器的线程

input.transform() shift. transform ();

output. transform (); // 直接输出结果

System.out.println(\ infile \(inputfile.hasNextLine()){ inputfile.nextLine();

System.out.println(str); }

System.out.println(\ Thread.sleep(3000);

System.out.println(\ outfile \ (outputfile.hasNextLine()){ System.out.println(str);

}

inputfile.close(); outputfile.close(); } catch (Exception

e){ e.getMessage();

} } }

//Filter类package kwic_pipe; import java.io.IOException;

public abstract class Filter { //定义输入管道

protected Pipe input; //定义输出管道 protected Pipe output; private boolean isStart = false;

Filter(Pipe input, Pipe

output){ this.input = input; this.output = output; }

// 防止多次调用，调用之后线程开始执行 public void start(){ if(!isStart){ isStart = true;

-----str = -----while Thread thread = new Thread(); thread.start(); } }

//线程的 run 方法 public void

run(){ try{

this.transform(); } catch (IOException

e){ e.getMessage();

} }

//将输入数据转换为所需数据并写入输出管道 //由子类实现抽象方法

protected abstract void transform()throws IOException; }

Pipe类

package kwic_pipe;

import java.io.IOException; import java.io.PipedReader; import java.io.PipedWriter; import java.io.PrintWriter; import java.util.Scanner;

public class Pipe { //输入管道

private Scanner pipereader; //输出管道

private PrintWriter pipewriter; public Pipe(){

PipedWriter pw = new PipedWriter(); PipedReader pr = new PipedReader(); try{

pw.connect(pr);

} catch (IOException e){ e.getMessage(); }

pipewriter = new PrintWriter(pw); pipereader = new Scanner(pr); }

//读入一行数据到管道 //@return 读入的数据

public String readerLine() throws

IOException{ return pipereader.nextLine(); }

//从管道输出一行数据

public void writerLine(String strline) throws IOException{ pipewriter.println(strline); }

//将读管道关闭，调用该方法后，不能再从管道中读数据 //如不能关闭则抛出异

public void closeReader() throws

IOException{ pipereader.close();

}

//先刷新数据，在将写管道关闭，调用该方法后，不能向管道中写数据 //如不能关闭则抛出异常

public void closeWriter() throws

IOException{ pipewriter.flush(); pipewriter.close(); }

} Alphabetizer类 package kwic_pipe;

import java.io.IOException; import java.util.ArrayList; import

java.util.Collections; public class Alphabetizer extends Filter{

private ArrayList al = new ArrayList();

Alphabetizer(Pipe input, Pipe

output){ super(input, output); }

//对读入的数据进行排序

protected void transform() throws IOException { String templine = null;

//读入数据

while((templine = input.readerLine()) != null){ al.add(templine); }

//按字母表排序

Collections.sort(al);

//对排序后的数据进行输出

for(int i = 0; i < al.size();

i++){ output.writerLine(al.get(i)); }

input.closeReader(); output.closeWriter(); }

} Shift类 package kwic_pipe;

import java.io.IOException; import java.util.ArrayList; public class Shift extends Filter{ //单词的列表

private ArrayList wordlist = new ArrayList(); //重组后的行的列表

private ArrayList linelist = new ArrayList();

Shift(Pipe input, Pipe

output){ super(input, output); }

@Override