//实现位图结构

package Bitmap;

import java.util.HashSet;

/**
 * @author 真他喵的学不动咯
 * @create 2022-08-12--21:01
 */
public class bit {  //实现位图结构
    public static class BitMap{
        //主函数测试
        public static void main(String[] args){
            System.out.println("*********测试**************");
            int max=1000;
            BitMap bitMap =new BitMap(max);   //位图，自己实现的
            HashSet<Integer> set=new HashSet<>();   //HashSet用于测试
            int testTime =100000;
            for (int i=0;i<testTime;i++){
                int num=(int)(Math.random()*(max+1));   //每一步生成的数都是随机的
                double decide = Math.random();
                if (decide<0.333){
                    bitMap.add(num);  //以1/3的概率共同加一个数   共同加一个数
                    set.add(num);
                }else if (decide<0.666){  //以0.666的概率删除一个数   共同删一个数
                    bitMap.delete(num);
                    set.remove(num);   //set是HashMap
                }else{   //共同查一个数
                    if (bitMap.contains(num)!=set.contains(num)){
                        System.out.println("***失败！查询的元素不一样***");
                        break;
                    }
                }
            }
            //数组中所有的数都查询一次
            for (int num=0;num<=max;num++){
                if (bitMap.contains(num) != set.contains(num)){
                    System.out.println("******不是所有元素都一样*****");
                }
            }

            System.out.println("***************测试结束啦啦~*****************");
        }

        private long[] bits;  //long64位
        //一个很长的数组，数组的每个元素能传很多位字节
        //long[10]，能够表示640个数，按位
        public BitMap(int max){
            // >>6意味着除以64    ,    (max+64)>>6意味着（max+64）/64
            // a/16等价于a>>4
            // max=0或者63时，（max+64）/64都是等于1
            //  0~0\0~63  都只需要准备1个long
            bits=new long[(max+64)>>6];   //找边界
            }


        //   170/64 表示要把这个数放在哪个long型段里面
        //   170%64 表示170在这个段的第几位
        // 0~63 64~127  ...
        //添加某个数
        public void add(int num){
            //  num/64  定位long型段  num>>6
            //  num%64  定位具体是哪一位 num&&63
            //  63=0111111 ，  num&&63就可以得出num是在哪位
            // num%64等价于num&&63，但是num&&63效率更快
            //  1L=0000001 （64位）  1L<<3等价于000100，把1左移3位
            // |= 等价于把找到的那一位加到long段里面
            // bits [num>>6] = bits [num>>6] | (1L<<(num &63));
            //                     ⬆                 ⬆
            //  定位long型段 = 定位long型段  |   把找到的那一位
            bits [num>>6] |= (1L<<(num &63));
       }


        //删掉一个数
        //num/64 得到是第几段    num&&63 得到是第几位
        //删掉的话，全部标0，就是删掉了
        //  11111011111  找到这样一个数，&，其他位不变，只有要删除的那一位是0
        //得到过程：
        //  00000100000    1<<5
        //  11111011111   ~1<<5   bits[num >> 6] =bits[num >> 6] & ~(1L << (num & 63));
        public void delete(int num) {
            bits[num >> 6] &= ~(1L << (num & 63));
        }
        //  1011010001011
        //  0000010000000
        // 这样这个数就是存在的
        //查询一个数
        public boolean contains(int num){
            return (bits[num>>6]&(1L<<(num&63)))!=0;  //如果这一段的这一位不等于0的时候，就是存在的
        }

        }
}
//day5 ‘’00‘’38‘’45