什么是Bitmap
Bit-map就是用一个bit位来标记某个元素对应的Value（若元素存在bit位置为1，不存在则置为0）。可创建一个整型数组（如byte数组，int数组，long数组）来表示
Bitmap原理
在Java中，数据类型int占4字节，4字节=32位（1 byte = 8 bit）
数据类型byte占1字节，1字节=8位
(1)用byte数组来表示 集合 {1,2,4,6}，byte数组一个元素占一个字节，一个字节占8位
计算机内存分配的最小单位是字节，也就是8位，那如果要表示集合{1,2,4,6,12,13,15},需要在byte数组，增加一个元素，即增加8位的数据来表示
（2)用int数组表示 集合{1,2,4,6,12,13,15}
1个int占32位（占4个字节，在实现上注意多个字节需要是考虑计算机存储Big-ending和Little-ending的情况），那么我们只需要申请一个int数组长度为 int tmp[1+N/32] 即可存储，其中N表示要存储的这些数中的最大值：
tmp[0]：可以表示0~31
tmp[1]：可以表示32~63
tmp[2]：可以表示64~95
例如用int数组表示 集合{1,2,4,6,12,13,15}，集合最大元素是15，则创建int数组长度是 1+15/32=1，则该int数组只有1个元素tmp[0] 就可以把这个集合全部数据表示进去，如下图：
如此一来，给定任意整数M，那么M/32就得到下标，M%32就知道它在此下标的哪个位置，详情见操作bitmap
操作bitmap
添加
依然用byte数组表示，byte数组的名字叫b，目前该数组已经表示了{1,2,4,6}，如何新增一个数字5，步骤如下：
首先，5/8=0，5%8=5，也是说它应该在b[0]的第5个位置，那我们把1向左移动5位，然后按位或
这就相当于 86 | 32 = 118
等价于 86 | (1<<5) = 118
等价于 b[0] = b[0] | (1<<5)
等价于 b[0] = b[0] | (1<<i%8)
通项公式为 b[插入数字/8] = b[插入数字/8] | (1<<i%8) i=插入的数字%8
也就是说，要想插入一个数，将1左移带代表该数字的那一位，然后与原数进行按位或操作
化简一下，就是 86 + (5/8) | (1<<(5%8))
因此，公式可以概括为：p + (i/8)|(1<<(i%8)) 其中，p表示现在的值，i=待插入的数%8（注意i刚好等于8的场景）
这里举例是以byte数组表示，如果以int数组表示
那么添加的两个通项公式为
b[插入的数字/32] = b[插入的数字/32] | (1<<i%32)
p + (i/32)|(1<<(i%32)) i=插入的数字%32
清除
还是上面的例子，依然以byte数组表示，假设我们要6移除，该怎么做呢？
从图上看，只需将该数所在的位置为0即可
1左移6位，就到达6这个数字所代表的位，然后按位取反，最后与原数按位与，这样就把该位置为0了
b[0] = b[0] & (~(1<<6))
b[0] = b[0] & (~(1<<(i%8)))
b[插入数字/8] = b[插入数字/8] & (~(1<<(i%8))) i=插入的数字%8
查找
前面我们也说了，每一位代表一个数字，1表示有（或者说存在），0表示无（或者说不存在）。通过把该为置为1或者0来达到添加和清除的小伙，那么判断一个数存不存在就是判断该数所在的位是0还是1
假设，我们想知道3在不在，那么只需判断 b[0] & (1<<3) 如果这个值是0，则不存在，如果是1，就表示存在。
通项公式 b[插入数字/8] & (1<<i%8) i=插入的数字%8
https://www.cnblogs.com/cjsblog/p/11613708.html
bitmap的java实现
因为java封装了bitmap使用起来非常方便，这里以java演示
import java.util.*;
public class maintest {
public static void main(String[] args) {
int[] array=new int[]{1,2,3,555,4,4};
BitSet bitSet =new BitSet(555); //填入数组的中最大元素，位图数组长度即为最大元素+1
//数组内容放入bitmap
for(int i=0;i<array.length;i++){
bitSet.set(array[i],true);
}
System.out.println(bitSet.size());
System.out.println(bitSet.get(3));
}
}
https://blog.csdn.net/gongpulin/article/details/81137548
利用bitmap去重
题目描述：
现在有五十亿个int类型的正整数，要从中找出重复的数并返回。
判断50亿个数有哪些是重复和刚才上面那个判断是否存在，其实是一样的。我们采用bitmap算法来做。不过这里50亿个数，别人肯定是以文件流的形式给你的。这样我们为了方便，我们就假设这些数是以存在int型数组的形式给我们的。
public class Test {
//为了方便，假设数据是以数组的形式给我们的
public static Set<Integer> test(int[] arr) {
int j = 0;
//用来把重复的数返回，存在Set里，这样避免返回重复的数。
Set<Integer> output = new HashSet<>();
BitSet bitSet = new BitSet(Integer.MAX_VALUE);
int i = 0;
while (i < arr.length) {
int value = arr[i];
//判断该数是否存在bitSet里
if (bitSet.get(value)) {
output.add(value);
} else {
bitSet.set(value, true);
}
i++;
}
return output;
}
//测试
public static void main(String[] args) {
int[] t = {1,2,3,4,5,6,7,8,3,4};
Set<Integer> t2 = test(t);
System.out.println(t2);
}
}
参考链接https://blog.csdn.net/qq_39478237/article/details/83692567
https://blog.csdn.net/pipisorry/article/details/62443757
BitMap应用：排序示例
假设我们要对0-7内的5个元素(4,7,2,5,3)排序（这里假设这些元素没有重复）。那么我们就可以采用Bit-map的方法来达到排序的目的。要表示8个数，我们就只需要8个Bit（1Bytes），首先我们开辟1Byte的空间，将这些空间的所有Bit位都置为0(如下图：)
然后遍历这5个元素，首先第一个元素是4，那么就把4对应的位置为1（可以这样操作 p+(i/8)|(0×01<<(i%8)) 当然了这里的操作涉及到Big-ending和Little-ending的情况，这里默认为Big-ending。不过计算机一般是小端存储的，如intel。小端的话就是将倒数第5位置1）,因为是从零开始的，所以要把第五位置为一（如下图）：
然后再处理第二个元素7，将第八位置为1,，接着再处理第三个元素，一直到最后处理完所有的元素，将相应的位置为1，这时候的内存的Bit位的状态如下：
然后我们现在遍历一遍Bit区域，将该位是一的位的编号输出（2，3，4，5，7），这样就达到了排序的目的。
实现代码
/**
* 进行数字排序
*/
public static void sortArray() {
int[] array = new int[] { 423, 700, 9999, 2323, 356, 6400, 1,2,3,2,2,2,2 };
BitSet bitSet = new BitSet(2 << 13);
// 虽然可以自动扩容，但尽量在构造时指定估算大小,默认为64
System.out.println("BitSet size: " + bitSet.size());
for (int i = 0; i < array.length; i++) {
bitSet.set(array[i]);
}
//剔除重复数字后的元素个数
int bitLen=bitSet.cardinality();
//进行排序，即把bit为true的元素复制到另一个数组
int[] orderedArray = new int[bitLen];
int k = 0;
for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
orderedArray[k++] = i;
}
System.out.println("After ordering: ");
for (int i = 0; i < bitLen; i++) {
System.out.print(orderedArray[i] + "\t");
}
System.out.println("iterate over the true bits in a BitSet");
//或直接迭代BitSet中bit为true的元素iterate over the true bits in a BitSet
for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
System.out.print(i+"\t");
}
System.out.println("---------------------------");
}
bitmap其他常用操作
import java.util.BitSet;
public class BitSetDemo {
public static void main(String args[]) {
BitSet bits1 = new BitSet(16);
BitSet bits2 = new BitSet(16);
// set some bits
for(int i=0; i<16; i++) {
if((i%2) == 0) bits1.set(i);
if((i%5) != 0) bits2.set(i);
}
System.out.println("Initial pattern in bits1: ");
System.out.println(bits1);
System.out.println("\nInitial pattern in bits2: ");
System.out.println(bits2);
// AND bits
bits2.and(bits1);
System.out.println("\nbits2 AND bits1: ");
System.out.println(bits2);
// OR bits
bits2.or(bits1);
System.out.println("\nbits2 OR bits1: ");
System.out.println(bits2);
// XOR bits
bits2.xor(bits1);
System.out.println("\nbits2 XOR bits1: ");
System.out.println(bits2);
}
}
package util;
import java.util.Arrays;
import java.util.BitSet;
public class BitSetDemo {
/**
* 求一个字符串包含的char
*
*/
public static void containChars(String str) {
BitSet used = new BitSet();
for (int i = 0; i < str.length(); i++)
used.set(str.charAt(i)); // set bit for char
StringBuilder sb = new StringBuilder();
sb.append("[");
int size = used.size();
System.out.println(size);
for (int i = 0; i < size; i++) {
if (used.get(i)) {
sb.append((char) i);
}
}
sb.append("]");
System.out.println(sb.toString());
}
/**
* 求素数 有无限个。一个大于1的自然数，如果除了1和它本身外，不能被其他自然数整除(除0以外）的数称之为素数(质数） 否则称为合数
*/
public static void computePrime() {
BitSet sieve = new BitSet(1024);
int size = sieve.size();
for (int i = 2; i < size; i++)
sieve.set(i);
int finalBit = (int) Math.sqrt(sieve.size());
for (int i = 2; i < finalBit; i++)
if (sieve.get(i))
for (int j = 2 * i; j < size; j += i)
sieve.clear(j);
int counter = 0;
for (int i = 1; i < size; i++) {
if (sieve.get(i)) {
System.out.printf("%5d", i);
if (++counter % 15 == 0)
System.out.println();
}
}
System.out.println();
}
/**
* 进行数字排序
*/
public static void sortArray() {
int[] array = new int[] { 423, 700, 9999, 2323, 356, 6400, 1,2,3,2,2,2,2 };
BitSet bitSet = new BitSet(2 << 13);
// 虽然可以自动扩容，但尽量在构造时指定估算大小,默认为64
System.out.println("BitSet size: " + bitSet.size());
for (int i = 0; i < array.length; i++) {
bitSet.set(array[i]);
}
//剔除重复数字后的元素个数
int bitLen=bitSet.cardinality();
//进行排序，即把bit为true的元素复制到另一个数组
int[] orderedArray = new int[bitLen];
int k = 0;
for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
orderedArray[k++] = i;
}
System.out.println("After ordering: ");
for (int i = 0; i < bitLen; i++) {
System.out.print(orderedArray[i] + "\t");
}
System.out.println("iterate over the true bits in a BitSet");
//或直接迭代BitSet中bit为true的元素iterate over the true bits in a BitSet
for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
System.out.print(i+"\t");
}
System.out.println("---------------------------");
}
/**
* 将BitSet对象转化为ByteArray
* @param bitSet
* @return
*/
public static byte[] bitSet2ByteArray(BitSet bitSet) {
byte[] bytes = new byte[bitSet.size() / 8];
for (int i = 0; i < bitSet.size(); i++) {
int index = i / 8;
int offset = 7 - i % 8;
bytes[index] |= (bitSet.get(i) ? 1 : 0) << offset;
}
return bytes;
}
/**
* 将ByteArray对象转化为BitSet
* @param bytes
* @return
*/
public static BitSet byteArray2BitSet(byte[] bytes) {
BitSet bitSet = new BitSet(bytes.length * 8);
int index = 0;
for (int i = 0; i < bytes.length; i++) {
for (int j = 7; j >= 0; j--) {
bitSet.set(index++, (bytes[i] & (1 << j)) >> j == 1 ? true
: false);
}
}
return bitSet;
}
/**
* 简单使用示例
*/
public static void simpleExample() {
String names[] = { "Java", "Source", "and", "Support" };
BitSet bits = new BitSet();
for (int i = 0, n = names.length; i < n; i++) {
if ((names[i].length() % 2) == 0) {
bits.set(i);
}
}
System.out.println(bits);
System.out.println("Size : " + bits.size());
System.out.println("Length: " + bits.length());
for (int i = 0, n = names.length; i < n; i++) {
if (!bits.get(i)) {
System.out.println(names[i] + " is odd");
}
}
BitSet bites = new BitSet();
bites.set(0);
bites.set(1);
bites.set(2);
bites.set(3);
bites.andNot(bits);
System.out.println(bites);
}
public static void main(String args[]) {
//BitSet使用示例
BitSetDemo.containChars("How do you do? 你好呀");
BitSetDemo.computePrime();
BitSetDemo.sortArray();
BitSetDemo.simpleExample();
//BitSet与Byte数组互转示例
BitSet bitSet = new BitSet();
bitSet.set(3, true);
bitSet.set(98, true);
System.out.println(bitSet.size()+","+bitSet.cardinality());
//将BitSet对象转成byte数组
byte[] bytes = BitSetDemo.bitSet2ByteArray(bitSet);
System.out.println(Arrays.toString(bytes));
//在将byte数组转回来
bitSet = BitSetDemo.byteArray2BitSet(bytes);
System.out.println(bitSet.size()+","+bitSet.cardinality());
System.out.println(bitSet.get(3));
System.out.println(bitSet.get(98));
for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
System.out.print(i+"\t");
}
}
}
遍历位图的方法
1.一个是使用bitmap自带的get方法
public class BitSetTest {
public static void main(String[] args) {
int [] array = new int [] {1,2,3,22,0,3,63};
BitSet bitSet = new BitSet(1);
System.out.println(bitSet.size()); //64
bitSet = new BitSet(65);
System.out.println(bitSet.size()); //128
bitSet = new BitSet(23);
System.out.println(bitSet.size()); //64
//将数组内容组bitmap
for(int i=0;i<array.length;i++)
{
bitSet.set(array[i], true);
}
System.out.println(bitSet.get(22));
System.out.println(bitSet.get(60));
System.out.println("下面开始遍历BitSet：");
for ( int i = 0; i < bitSet.size(); i++ ){
System.out.println(bitSet.get(i)); //如果是位的值为1,那么返回ture
}
}
}
2.另一个是使用bitmap自带的nextSetBit()方法
示例一
// Java program illustrating Bitset
// nextSetBit() function.
import java.util.*;
public class GFG {
public static void main(String[] args)
{
// Constructors of BitSet class
BitSet bs1 = new BitSet();
BitSet bs2 = new BitSet();
BitSet bs3 = new BitSet();
/* assigning values to set1*/
bs1.set(0);
bs1.set(1);
bs1.set(2);
bs1.set(4);
// assign values to bs2
bs2.set(4);
bs2.set(6);
bs2.set(5);
bs2.set(1);
bs2.set(2);
bs2.set(3);
bs2.set(12);
// Printing the 2 Bitsets
System.out.println("bs1 : " + bs1);
System.out.println("bs2 : " + bs2);
System.out.println("bs3 : " + bs3);
// Performing nextSetBit() on bitsets
System.out.println(bs1.nextSetBit(2));
System.out.println(bs2.nextSetBit(0));
System.out.println(bs3.nextSetBit(3));
}
}
示例2，基于数组排序
/**
* 进行数字排序
*/
public static void sortArray() {
int[] array = new int[] { 423, 700, 9999, 2323, 356, 6400, 1,2,3,2,2,2,2 };
BitSet bitSet = new BitSet(2 << 13);
// 虽然可以自动扩容，但尽量在构造时指定估算大小,默认为64
System.out.println("BitSet size: " + bitSet.size());
for (int i = 0; i < array.length; i++) {
bitSet.set(array[i]);
}
//剔除重复数字后的元素个数
int bitLen=bitSet.cardinality();
//进行排序，即把bit为true的元素复制到另一个数组
int[] orderedArray = new int[bitLen];
int k = 0;
for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
orderedArray[k++] = i;
}
System.out.println("After ordering: ");
for (int i = 0; i < bitLen; i++) {
System.out.print(orderedArray[i] + "\t");
}
System.out.println("iterate over the true bits in a BitSet");
//或直接迭代BitSet中bit为true的元素iterate over the true bits in a BitSet
for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
System.out.print(i+"\t");
}
System.out.println("---------------------------");
}
参考链接
https://vimsky.com/examples/usage/bitset-nextsetbit-method-in-java.html
https://www.jianshu.com/p/8d074e8d02aa?utm_campaign=hugo
https://blog.csdn.net/cumudi0723/article/details/107796132
1182
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
