Bitmap

##Bitmap

 package edu.nwpu.bitmap;

import java.util.Random;

/**

 * @author fanruilong
   *
    */

public class Bitmap {
private byte[] bits;

private final int MAX_BIT_LEN = 7;

private final int MB = 1024 * 1024 * 10;

private final int MAX_VALUE = MAX_BIT_LEN * MB;

public Bitmap() {

	bits = new byte[MAX_VALUE];

}

public void add(int n) {

	if (n >= MAX_VALUE) {

		throw new RuntimeException("超出最大的存储范围 ");

	}

	int index = n / MAX_BIT_LEN;// 计算是数组中的哪个元素
	int pos = n % MAX_BIT_LEN;// 荻取bit位在byte中位置
	int offset = (1 << pos);// 将00000001左移pos位

	bits[index] |= offset;

}

public boolean contains(int n) {

	if (n >= MAX_VALUE) {

		throw new RuntimeException("超出最大范围");

	}
	int index = n / MAX_BIT_LEN;// 获取bit位在byte的位置
	int pos = n % MAX_BIT_LEN;// 荻取bit位在byte中位霊

	int offset = (1 << pos);

	return (bits[index] & offset) != 0;

}

/**
 * 根据输入的值，清除指定位置的1（将其变为0）
 * 
 * @param n 输入的值
 */

public void clear(int n) {

	if (n >= MAX_VALUE) {

		throw new RuntimeException("超出最大的存储范围 ");

	}

	int index = n / MAX_BIT_LEN;// 计算是数组中的哪个元素
	int pos = n % MAX_BIT_LEN;// 荻取bit位在byte中位置
	int offset = (1 << pos);// 将00000001左移pos位

	bits[index] &= ~offset;

}

public void show() {

	for (int i = 0; i < bits.length; i++) {

		System.out.println(i + ">> " + Integer.toBinaryString(bits[i]));
	}
}

public static void main(String[] args) {

	Bitmap map = new Bitmap();

	Random ran = new Random();

	for (int i = 0; i < 10; i++) {

		map.add(ran.nextInt(45));
	}

	map.add(100000);
	System.out.println(map.contains(100000));
	map.clear(100000);
	System.out.println(map.contains(45));
	System.out.println(map.contains(100000));
}
}

布隆过滤器

public class MyBloomFilter {
/**
 * 一个长度为10 亿的比特位
 */
private static final int DEFAULT_SIZE = 256 << 22;
 
/**
 * 为了降低错误率，使用加法hash算法，所以定义一个8个元素的质数数组
 */
private static final int[] seeds = {3, 5, 7, 11, 13, 31, 37, 61};
 
/**
 * 相当于构建 8 个不同的hash算法
 */
private static HashFunction[] functions = new HashFunction[seeds.length];
 
/**
 * 初始化布隆过滤器的 bitmap
 */
private static BitSet bitset = new BitSet(DEFAULT_SIZE);
 
/**
 * 添加数据
 *
 * @param value 需要加入的值
 */
public static void add(String value) {
    if (value != null) {
        for (HashFunction f : functions) {
            //计算 hash 值并修改 bitmap 中相应位置为 true
            bitset.set(f.hash(value), true);
        }
    }
}
 
/**
 * 判断相应元素是否存在
 * @param value 需要判断的元素
 * @return 结果
 */
public static boolean contains(String value) {
    if (value == null) {
        return false;
    }
    boolean ret = true;
    for (HashFunction f : functions) {
        ret = bitset.get(f.hash(value));
        //一个 hash 函数返回 false 则跳出循环
        if (!ret) {
            break;
        }
    }
    return ret;
}
 
/**
 * 测试。。。
 */
public static void main(String[] args) {
 
    for (int i = 0; i < seeds.length; i++) {
        functions[i] = new HashFunction(DEFAULT_SIZE, seeds[i]);
    }
 
    // 添加1亿数据
    for (int i = 0; i < 100000000; i++) {
        add(String.valueOf(i));
    }
    String id = "123456789";
    add(id);
 
    System.out.println(contains(id));   // true
    System.out.println("" + contains("234567890"));  //false
}
}

class HashFunction {

    private int size;
    private int seed;
     
    public HashFunction(int size, int seed) {
        this.size = size;
        this.seed = seed;
    }
     
    public int hash(String value) {
        int result = 0;
        int len = value.length();
        for (int i = 0; i < len; i++) {
            result = seed * result + value.charAt(i);
        }
        int r = (size - 1) & result;
        return (size - 1) & result;
    }

}

数据稀疏

稀疏数据是指，数据框中绝大多数数值缺失或者为零的数据。在现代社会中，随着信息的爆炸式增长，数据量也呈现出爆炸式增长，数据形式也越来越多样化。在数据挖掘领域，常常要面对海量的复杂型数据。其中，稀疏数据这一特殊形式的数据正在越来越为人们所注意。
　　稀疏数据绝对不是无用数据，只不过是信息不完全，通过适当的手段是可以挖掘出大量有用信息的。然而在一些情况下，数据的稀疏程度甚至会达到 95%以上，这使得传统的统计方法不适于处理此类数据