mike
study
day
get
last
exam
think
fish
he

play
mike
study
day
get
Axis
last
exam
think
fish
he

package BloomFilter;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashMap;
import java.util.Map;

/**
 * 布隆過濾器算法工具類
 * 
 * @author lyq
 * 
 */
public class BloomFilterTool {
	// 位數(shù)組設(shè)置為10w位的長度
	public static final int BIT_ARRAY_LENGTH = 100000;

	// 原始文檔地址
	private String filePath;
	// 測試文檔地址
	private String testFilePath;
	// 用于存儲的位數(shù)組,一個單元用1個位存儲
	private BitSet bitStore;
	// 原始數(shù)據(jù)
	private ArrayList totalDatas;
	// 測試的查詢數(shù)據(jù)
	private ArrayList queryDatas;

	public BloomFilterTool(String filePath, String testFilePath) {
	this.filePath = filePath;
	this.testFilePath = testFilePath;

	this.totalDatas = readDataFile(this.filePath);
	this.queryDatas = readDataFile(this.testFilePath);
	}

	/**
	 * 從文件中讀取數(shù)據(jù)
	 */
	public ArrayList readDataFile(String path) {
	File file = new File(path);
	ArrayList dataArray = new ArrayList();

	try {
	BufferedReader in = new BufferedReader(new FileReader(file));
	String str;
	String[] tempArray;
	while ((str = in.readLine()) != null) {
	tempArray = str.split(" ");
	for(String word: tempArray){
	dataArray.add(word);
	}
	}
	in.close();
	} catch (IOException e) {
	e.getStackTrace();
	}

	return dataArray;
	}
	
	/**
	 * 獲取查詢總數(shù)據(jù)
	 * @return
	 */
	public ArrayList getQueryDatas(){
	return this.queryDatas;
	}

	/**
	 * 用位存儲數(shù)據(jù)
	 */
	private void bitStoreData() {
	long hashcode = 0;
	bitStore = new BitSet(BIT_ARRAY_LENGTH);

	for (String word : totalDatas) {
	// 對每個詞進(jìn)行3次哈希求值，減少哈希沖突的概率
	hashcode = BKDRHash(word);
	hashcode %= BIT_ARRAY_LENGTH;

	
	bitStore.set((int) hashcode, true);

	hashcode = SDBMHash(word);
	hashcode %= BIT_ARRAY_LENGTH;

	bitStore.set((int) hashcode, true);

	hashcode = DJBHash(word);
	hashcode %= BIT_ARRAY_LENGTH;

	bitStore.set((int) hashcode, true);
	}
	}

	/**
	 * 進(jìn)行數(shù)據(jù)的查詢，判斷原數(shù)據(jù)中是否存在目標(biāo)查詢數(shù)據(jù)
	 */
	public Map queryDatasByBF() {
	boolean isExist;
	long hashcode;
	int pos1;
	int pos2;
	int pos3;
	// 查詢詞的所屬情況圖
	Map word2exist = new HashMap();

	hashcode = 0;
	isExist = false;
	bitStoreData();
	for (String word : queryDatas) {
	isExist = false;
	
	hashcode = BKDRHash(word);
	pos1 = (int) (hashcode % BIT_ARRAY_LENGTH);

	hashcode = SDBMHash(word);
	pos2 = (int) (hashcode % BIT_ARRAY_LENGTH);

	hashcode = DJBHash(word);
	pos3 = (int) (hashcode % BIT_ARRAY_LENGTH);

	// 只有在3個哈希位置都存在才算真的存在
	if (bitStore.get(pos1) && bitStore.get(pos2) && bitStore.get(pos3)) {
	isExist = true;
	}

	// 將結(jié)果存入map
	word2exist.put(word, isExist);
	}

	return word2exist;
	}

	/**
	 * 進(jìn)行數(shù)據(jù)的查詢采用普通的過濾器方式就是，逐個查詢
	 */
	public Map queryDatasByNF() {
	boolean isExist = false;
	// 查詢詞的所屬情況圖
	Map word2exist = new HashMap();

	// 遍歷的方式去查找
	for (String qWord : queryDatas) {
	isExist = false;
	for (String word : totalDatas) {
	if (qWord.equals(word)) {
	isExist = true;
	break;
	}
	}

	word2exist.put(qWord, isExist);
	}

	return word2exist;
	}

	/**
	 * BKDR字符哈希算法
	 * 
	 * @param str
	 * @return
	 */
	private long BKDRHash(String str) {
	int seed = 31; /* 31 131 1313 13131 131313 etc.. */
	long hash = 0;
	int i = 0;

	for (i = 0; i < str.length(); i++) {
	hash = (hash * seed) + (str.charAt(i));
	}

	hash = Math.abs(hash);
	return hash;
	}

	/**
	 * SDB字符哈希算法
	 * 
	 * @param str
	 * @return
	 */
	private long SDBMHash(String str) {
	long hash = 0;
	int i = 0;
	
	for (i = 0; i < str.length(); i++) {
	hash = (str.charAt(i)) + (hash << 6) + (hash << 16) - hash;
	}

	hash = Math.abs(hash);
	return hash;
	}

	/**
	 * DJB字符哈希算法
	 * 
	 * @param str
	 * @return
	 */
	private long DJBHash(String str) {
	long hash = 5381;
	int i = 0;

	for (i = 0; i < str.length(); i++) {
	hash = ((hash << 5) + hash) + (str.charAt(i));
	}

	hash = Math.abs(hash);
	return hash;
	}

}

package BloomFilter;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Map;

/**
 * BloomFileter布隆過濾器測試類
 * 
 * @author lyq
 * 
 */
public class Client {
	public static void main(String[] args) {
	String filePath = "C:\\Users\\lyq\\Desktop\\icon\\input.txt";
	String testFilePath = "C:\\Users\\lyq\\Desktop\\icon\\testInput.txt";
	// 總的查詢詞數(shù)
	int totalCount;
	// 正確的結(jié)果數(shù)
	int rightCount;
	long startTime = 0;
	long endTime = 0;
	// 布隆過濾器查詢結(jié)果
	Map bfMap;
	// 普通過濾器查詢結(jié)果
	Map nfMap;
	//查詢總數(shù)據(jù)
	ArrayList queryDatas;

	BloomFilterTool tool = new BloomFilterTool(filePath, testFilePath);

	// 采用布隆過濾器的方式進(jìn)行詞的查詢
	startTime = System.currentTimeMillis();
	bfMap = tool.queryDatasByBF();
	endTime = System.currentTimeMillis();
	System.out.println("BloomFilter算法耗時" + (endTime - startTime) + "ms");

	// 采用普通過濾器的方式進(jìn)行詞的查詢
	startTime = System.currentTimeMillis();
	nfMap = tool.queryDatasByNF();
	endTime = System.currentTimeMillis();
	System.out.println("普通遍歷查詢操作耗時" + (endTime - startTime) + "ms");

	boolean isExist;
	boolean isExist2;

	rightCount = 0;
	queryDatas = tool.getQueryDatas();
	totalCount = queryDatas.size();
	for (String qWord: queryDatas) {
	// 以遍歷的查詢的結(jié)果作為標(biāo)準(zhǔn)結(jié)果
	isExist = nfMap.get(qWord);
	isExist2 = bfMap.get(qWord);

	if (isExist == isExist2) {
	rightCount++;
	}else{
	System.out.println("預(yù)判錯誤的詞語：" + qWord);
	}
	}
	System.out.println(MessageFormat.format(
	"Bloom Filter的正確個數(shù)為{0}，總查詢數(shù)為{1}個，正確率{2}", rightCount,
	totalCount, 1.0 * rightCount / totalCount));
	}
}

BloomFilter算法耗時2ms
普通遍歷查詢操作耗時0ms
Bloom Filter的正確個數(shù)為11，總查詢數(shù)為11個，【本文來自鴻網(wǎng)互聯(lián) (http://www.68idc.cn)】正確率1

BloomFilter算法耗時16ms
普通遍歷查詢操作耗時47ms
Bloom Filter的正確個數(shù)為2,743，總查詢數(shù)為2,743個，正確率1