bi-gram implementation
import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class kGram {
HashMap<String, Integer> terms = new HashMap<String, Integer>();
HashMap<String, ArrayList<String>> kindex = new HashMap<String, ArrayList<String>>();
HashMap<String, Integer> result = new HashMap<String, Integer>();
String[] resultArray;
Boolean flag;
String sKey;
static final int K = 2;
public static void main(String args[]) {
try {
String queries = null;
BufferedReader in = null;
in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
kGram kg = new kGram();
kg.read("directory.csv");
// kg.read("simple.csv");
kg.buildIndex(kGram.K);
// dump out the K-gram index
// kg.dumpMap(kg.kindex);
// kg.set_sKey("comp");
// kg.searching(kg.get_sKey());
// kg.sort();
// kg.print();
while (true) {
System.out.println("Enter query (no '*' at the end): ");
queries = in.readLine();
queries = queries.trim();
if (queries.length() <= 0) {
System.out.println("No input! Exit");
return;
} else if (queries.length() <= 1) {
System.out.println("Query is at least 2 characters: ");
continue;
}
System.out.println();
kg.set_sKey(queries);
kg.searching(queries);
if (kg.flag == true) {
kg.sort();
kg.print();
} else {
System.out.println("No suggestion!");
}
}
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
public void set_sKey(String s) {
this.sKey = s;
}
public String get_sKey() {
return this.sKey;
}
public void read(String input) {
try {
// Open the file that is the first
FileInputStream fstream = new FileInputStream(input);
// Get the object of DataInputStream
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
// Read File Line By Line
while ((strLine = br.readLine()) != null) {
// split string to array
String[] temp = null;
temp = strLine.split("/t");
this.buildTerms(temp);
}
// Close the input stream
in.close();
} catch (Exception e) {// Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
public void buildTerms(String[] item) {
this.terms.put(item[0], Integer.parseInt(item[1]));
}
public void buildIndex(int k) {
Set<Map.Entry<String, Integer>> set = this.terms.entrySet();
Iterator<Map.Entry<String, Integer>> i = set.iterator();
ArrayList<String> strarr;
String[] str;
while (i.hasNext()) {
Map.Entry<String, Integer> me = (Map.Entry<String, Integer>) i
.next();
String term = me.getKey();
if (term.length() > 1) {
str = this.segment(term, k);
for (int j = 0; j < str.length; j++) {
String key = str[j];
if (this.kindex.containsKey(key)) {
strarr = this.kindex.get(key);
strarr.add(term);
} else {
strarr = new ArrayList<String>();
strarr.add(term);
this.kindex.put(key, strarr);
}
}
}
}
}
private String[] segment(String s, int k) {
int i = s.length();
String[] str = new String[i];
for (int j = 0; j < i; j++) {
if (j - 1 >= 0)
str[j] = s.substring(j - 1, j - 1 + k);
else
str[j] = s.substring(0, 1);
}
return str;
}
public void dumpMap(HashMap hm) {
Set set = hm.entrySet();
Iterator i = set.iterator();
while (i.hasNext()) {
Map.Entry me = (Map.Entry) i.next();
System.out.println(me.getKey() + " => " + me.getValue());
}
}
public void searching(String str) {
this.flag = false;
HashMap<String, ArrayList<String>> resultMap = new HashMap<String, ArrayList<String>>();
String[] s = this.segment(str, kGram.K);
for (int i = 0; i < s.length; i++) {
String key = s[i];
if (this.kindex.containsKey(key)) {
ArrayList<String> temp = this.kindex.get(key);
resultMap.put(key, temp);
}
}
// intersection
Set<String> sets2 = null;
if (!resultMap.isEmpty()) {
Collection<ArrayList<String>> c = resultMap.values();
Iterator<ArrayList<String>> ite = c.iterator();
Set<String> sets1 = new HashSet<String>(ite.next());
while (ite.hasNext()) {
sets2 = new HashSet<String>(ite.next());
sets2.retainAll(sets1);
}
if (sets2.isEmpty())
sets2 = sets1;
}
// generate result
this.resultArray = sets2.toArray(new String[0]);
for (int i = 0; i < resultArray.length; i++) {
this.result.put((String) resultArray[i], this.terms
.get(resultArray[i]));
}
if (this.resultArray.length > 0)
// System.out.println(java.util.Arrays.toString(this.resultArray));
this.flag = true;
}
public void sort() {
if (!this.result.isEmpty()) {
// Insertion sort
for (int i = 1; i <= (this.resultArray.length - 1); i++) {
String cur = this.resultArray[i];
int current = this.result.get(this.resultArray[i]);
int position = i - 1;
while (position >= 0
&& current > this.result
.get(this.resultArray[position])) {
this.resultArray[position + 1] = this.resultArray[position];
position = position - 1;
}
this.resultArray[position + 1] = cur;
}
}
}
public void print() {
// print result with frequency
int count = 0;
for (int i = 0; i < this.resultArray.length; i++) {
if (this.filter(this.resultArray[i])) {
System.out.println(this.resultArray[i] + " ("
+ this.result.get(this.resultArray[i]) + ")");
count++;
if (i > 3)
break;
}
}
if (count == 0) {
System.out.println("Sorry, no matching!");
System.out.println();
} else
System.out.println();
}
// filter result
// for example search "com" should not return "income"
private boolean filter(String s) {
String key = this.get_sKey();
String str = s.substring(0, key.length());
if (key.equals(str))
return true;
else
return false;
}
}
一个很有用的小技巧，直接dump输出数组内容：
public class Test {
public static void main(String args[]) {
String s[] = {"a", "b", "c", "d"};
double d [][]= {
{0.50, 0.70, 0.40, 0.60},
{0.50, 1.10, 0.50, 0.80}
};
System.out.println(java.util.Arrays.toString(s));
System.out.println(java.util.Arrays.deepToString(d));
// output
// [a, b, c, d]
// [[0.5, 0.7, 0.4, 0.6], [0.5, 1.1, 0.5, 0.8]]
}
}
或者
public class Test {
public static void main(String args[]) {
String s[] = {"a", "b", "c", "d"};
for (String element : s)
System.out.println(element);
}
}
