基于面向对象(抽象数据类型)风格的kwic实现

ObjectOrientedMain类

/**
 * 
 */
package com.jason.kwic.objectOriented;

import java.io.IOException;

/**
 * @author jasonzhang
 *
 */
public class ObjectOrientedMain {

	public static void main(String[] args) throws IOException {
		Output output = new Output();
		Alphabetizer sorter = new Alphabetizer(output);
		Shift shift = new Shift(sorter);
		Input input  = new Input(shift);
		input.input("d:\\temp\\mykwic_in.txt");
		shift.shift();
		sorter.sort();
	}
}

Output类

/**
 * 
 */
package com.jason.kwic.objectOriented;

import java.util.ArrayList;

/**
 * @author jasonzhang
 *
 */
public class Output {

	public void output(ArrayList<String> lines) {
		System.out.println("output is");
		 for (String line : lines) {
			System.out.println(line);
		 }
	}
}

Alphabetizer类

/**
 * 
 */
package com.jason.kwic.objectOriented;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * @author jasonzhang
 *
 */
public class Alphabetizer {
	private ArrayList<String> lines = new ArrayList<String>();

	private Output output;
	public Alphabetizer(Output output) {
		this.output = output;
	}
	public void addLine(String line) {
		this.lines.add(line);
	}
	public void sort() {
		 Collections.sort(this.lines, new AlphaabetizerComparator());
		this.output.output(this.lines);
	}
	
	private class AlphaabetizerComparator implements Comparator<String> {

		@Override
		public int compare(String o1, String o2) {
			if (o1 == null || o2 == null) {
	            throw new NullPointerException();
	        }
			int compareValue = 0;
			char o1FirstCharacter = o1.charAt(0);
			char o2FirstCharacter = o2.charAt(0);
			if(this.isLetter(o1FirstCharacter) && this.isLetter(o2FirstCharacter)) {
				//如果是小写的字母的值,则转成对应的大写的字母的值
				o1FirstCharacter = this.toUpperCase(o1FirstCharacter);
				o2FirstCharacter = this.toUpperCase(o2FirstCharacter);
				compareValue = o1FirstCharacter - o2FirstCharacter;
			} else {
				throw new RuntimeException("必须是字母");
			}
			return compareValue;
		}
		
		private boolean isLetter(char c) {
			return (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
		}
		
		private char toUpperCase(char c) {
			if (Character.isLowerCase(c)) {
				return Character.toUpperCase(c);
			}
			return c;
		}
    	
    }
}

Shift类

/**
 * 
 */
package com.jason.kwic.objectOriented;

import java.util.ArrayList;
import java.util.StringTokenizer;

/**
 * @author jasonzhang
 *
 */
public class Shift {
	
	private ArrayList<String> lines = new ArrayList<String>();
	
	//private ArrayList<String> shifedLines = new ArrayList<String>();
	
	private Alphabetizer sorter;
	
	public Shift(Alphabetizer sorter) {
		this.sorter = sorter;
	}
	
	public void addLine(String line) {
		this.lines.add(line);
	}

	public void shift() {
		for (String line : this.lines) {
			this.shiftLine(line);
		}
	}
	
	private void shiftLine(String line) {
		ArrayList<String> wordList = new ArrayList<String>();
		StringTokenizer st = new StringTokenizer(line, " ");
		while (st.hasMoreTokens()) {
			wordList.add(st.nextToken());
		}
		int wordNums = wordList.size();
		StringBuilder tempLine = new StringBuilder();
		//System.out.println("shifed is");
		for (int i=0; i<wordNums; i++) {
			for (int j=(wordNums - 1 -i); j < wordNums; j++) {
				tempLine.append(wordList.get(j)).append(' ');
			}
			for (int k=0; k<(wordNums - 1 -i); k++) {
				if (k != (wordNums - i - 2)) {
					tempLine.append(wordList.get(k)).append(' ');
				} else {
					tempLine.append(wordList.get(k));
				}
			}
			//System.out.println(tempLine.toString());
			//this.shifedLines.add(tempLine.toString());
			this.sorter.addLine(tempLine.toString());
			tempLine.delete(0, tempLine.length());
		}
	}
}

Input类

/**
 * 
 */
package com.jason.kwic.objectOriented;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

/**
 * @author jasonzhang
 *
 */
public class Input {
	private Shift shift;
	
	public Input(Shift shift) {
		this.shift = shift;
	}
	
	public void input(String filePath) throws IOException {
		File infile = new File(filePath);
		Scanner sc = new Scanner(infile);
		String tempLine = null;
		System.out.println("input is");
		while (sc.hasNextLine()) {
			tempLine = sc.nextLine();
			System.out.println(tempLine);
			this.shift.addLine(tempLine);
		}
	}
}


转载于:https://my.oschina.net/u/914897/blog/409936

  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
KWIC(Key Word In Context)是一种文本处理技术,用于生成索引或摘要。基于隐式调用风格KWIC实现是一种基于函数调用的方式实现KWIC的方法。以下是一个简单的Python代码实现: ```python def kwic(text, keyword): """ 基于隐式调用风格KWIC实现 """ def shift(lst): return [lst[i:] + lst[:i] for i in range(len(lst))] lines = text.split('\n') phrases = [line.strip().split() for line in lines if line.strip()] shifted_phrases = [shift(phrase) for phrase in phrases] indexed_phrases = [(i, phrase) for i, phrase in enumerate(shifted_phrases)] keyword_indices = [i for i, phrase in indexed_phrases for word in phrase if word == keyword] results = [] for i in keyword_indices: phrase = shifted_phrases[i] line = lines[indexed_phrases[i][0]] results.append((line, ' '.join(phrase))) return results ``` 在这个实现中,我们定义了一个`kwic`函数,该函数接受两个参数:`text`表示要处理的文本,`keyword`表示要查找的关键字。函数内部定义了一个`shift`函数,该函数接受一个列表并返回其所有可能的循环移位版本。 接下来,我们将输入文本分割成行,并将每行转换为一个单词列表。然后,对于每个单词列表,我们生成所有可能的循环移位版本,并将其与原始列表一起索引。接下来,我们查找所有包含关键字的单词列表,并将它们的索引与原始文本行一起返回。 这种实现方法的一个优点是它可以很容易地进行扩展,例如,我们可以将`shift`函数替换为一个更复杂的移位算法,或者将关键字匹配改为不区分大小写或使用正则表达式。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值