package com.hlj.util.Z005BitSet;

import lombok.extern.slf4j.Slf4j;

/**
 * @author zhangyujin
 * @date 2022/6/30  18:02.
 */
@Slf4j
public class StatusEnums {
  
    private final static long INIT = 1L << 0;
    private final static long CHSI_VERIFY = 1L << 1;
    private final static long GRADUATE = 1L << 2;

  
    static {
       
        System.out.println(Long.toBinaryString(INIT));
       
        System.out.println(Long.toBinaryString(CHSI_VERIFY));
        System.out.println(Long.toBinaryString(GRADUATE));
        System.out.println();
    }


    /**
     * 是否包含状态
     *
     * @param holder   当前状态
     * @param position 标志位状态
     * @return
     */
    public static boolean hasStatus(long holder, long position) {
        return (holder & position) == position;
    }

    /**
     * 添加状态
     *
     * @param holder   当前状态
     * @param position 添加状态标志位
     * @return 新状态
     */
    public static long addStatus(long holder, long position) {
        if (hasStatus(holder, position)) {
            return holder;
        }
        return holder | position;
    }

    /**
     * 移除状态
     *
     * @param holder   当前状态
     * @param position 移除状态标志位
     * @return 新状态
     */
    public static long removeStatus(long holder, long position) {
        if (!hasStatus(holder, position)) {
            return holder;
        }
        //异或移除
        return holder ^ position;
    }

  
  
    public static void main(String[] args) {
        long holder = 7L;
        System.out.println(Long.toBinaryString(holder));
        //0111

        System.out.println(StatusEnums.hasStatus(holder, INIT));
        // true -> 0001 在 0111 中
        System.out.println(StatusEnums.hasStatus(holder, CHSI_VERIFY));
        // true -> 0010 在 0111 中
        System.out.println(StatusEnums.hasStatus(holder, GRADUATE));
        // tuue -> 0100 在 0111 中

        holder = StatusEnums.removeStatus(holder, INIT);
        holder = StatusEnums.removeStatus(holder, CHSI_VERIFY);
        holder = StatusEnums.removeStatus(holder, GRADUATE);
        System.out.println(Long.toBinaryString(holder));
        //0000
        System.out.println(StatusEnums.hasStatus(holder, INIT));
        // false -> 0001 不在 0111 中
        System.out.println(StatusEnums.hasStatus(holder, CHSI_VERIFY));
        // false -> 0010 不在 0111 中
        System.out.println(StatusEnums.hasStatus(holder, GRADUATE));
        // false -> 0100 不在 0111 中
    }
}

package com.hlj.util.Z005BitSet;

import java.util.*;

/**
 * @author zhangyujin
 * @date 2022/6/30  18:15.
 */
public class Sign {

    //int最多可以容纳32位，0b表示需jdk1.8+支持,左边第一位永远为0，即正整数，无日期含义；右边31位表示日期，从左到右1-31天
    private final static int monthSignRecord = 0b01111111111111111111111111111000;
    private final static int DAY28 = 0x7ffffff8;
    private final static int DAY29 = 0x7ffffffc;
    private final static int DAY30 = 0x7ffffffe;
    private final static int DAY31 = 0x7fffffff;
    private final static int MONTH_MODEL = 0x40000000;
    private final static Calendar CALENDAR = Calendar.getInstance(Locale.CHINA);

    /**
     * 签到总数
     *
     * @param holder 签到记录
     * @return
     */
    public static int signCount(int holder) {
        return Integer.bitCount(holder);
    }

    /**
     * 获取指定月是否全签到
     *
     * @param holder 签到记录
     * @return
     */
    public static boolean isSignFullInFixedMonth(int holder, int month) {
        CALENDAR.set(Calendar.MONTH, month - 1);
        int days = CALENDAR.getActualMaximum(Calendar.DATE);

        switch (days) {
            case 28:
                return (holder & DAY28) == DAY28;
            case 29:
                return (holder & DAY29) == DAY29;
            case 30:
                return (holder & DAY30) == DAY30;
            case 31:
                return (holder & DAY31) == DAY31;
        }
        throw new IllegalArgumentException("month is illegal");
    }

    /**
     * 获取指定月漏签次数
     *
     * @param holder 签到记录
     * @return
     */
    public static int unSignCountInFixedMonth(int holder, int month) {
        // java 月份从0开始算，因此传入的月份需要减去1
        CALENDAR.set(Calendar.MONTH, month - 1);
        return CALENDAR.getActualMaximum(Calendar.DATE) - Integer.bitCount(holder);
    }

    /**
     * 指定天是否签到
     *
     * @param holder   当前签到标识
     * @param position 签到天标识位
     * @return
     */
    public static boolean isSignInFixedDay(int holder, int position) {
        return (holder & position) == position;
    }

    /**
     * 按照天签到
     *
     * @param holder   当前签到标识
     * @param position 签到天标识位
     * @return 新签到标识
     */
    public static int signInFixedDay(int holder, int position) {
        if (isSignInFixedDay(holder, position)) {
            return holder;
        }
        return holder | position;
    }

    /**
     * 批量签到，适合补签场景
     *
     * @param holder 当前签到标识
     * @param days   批量签到序号
     * @return 新签到标识
     */
    public static int batchSign(int holder, List<Integer> days) {
        Iterator<Integer> it = days.iterator();
        while (it.hasNext()) {
            holder = holder | getPosition(it.next());
        }
        return holder;
    }

    public static int getPosition(int position) {
        //0b01000000000000000000000000000000 == 0x40000000 左边第一位永远为0，即正整数，无日期含义；右边31位表示日期，从右到左1-31天
        return MONTH_MODEL >>> (position - 1);
    }

    public static void main(String[] args) {
        int month = 5;
        System.out.printf("签到记录：【%s】 %n", Integer.toBinaryString(monthSignRecord));
        // 签到记录：【1111111111111111111111111111000】

        System.out.printf("签到总数：【%d】 %n", signCount(monthSignRecord));
        // 签到总数：【28】

        System.out.printf("%d月漏签总数 %d %n", month, unSignCountInFixedMonth(monthSignRecord, month));
        // 5月漏签总数 3

        System.out.printf("全月是否全部签到 %b %n", isSignFullInFixedMonth(monthSignRecord, month));
        // 全月是否全部签到 false

        System.out.printf("签到前【%s】%n", Integer.toBinaryString(monthSignRecord));
        // 签到前【1111111111111111111111111111000】

        int signTemp = signInFixedDay(monthSignRecord, getPosition(30));
        signTemp = signInFixedDay(signTemp, getPosition(31));
        System.out.printf("签到后【%s】%n", Integer.toBinaryString(signTemp));
        // 签到后【1111111111111111111111111111011】

        System.out.printf("全月是否全部签到 %b %n", isSignFullInFixedMonth(signTemp, month));
        // 全月是否全部签到 false

        System.out.printf("批量签到前【%s】%n", Integer.toBinaryString(monthSignRecord));
        // 批量签到前【1111111111111111111111111111000】

        int signBatch = batchSign(monthSignRecord, Arrays.asList(29, 30, 31));
        System.out.printf("批量签到后【%s】%n", Integer.toBinaryString(signBatch));
        // 批量签到后【1111111111111111111111111111111】
        
        System.out.printf("全月是否全部签到 %b %n", isSignFullInFixedMonth(signBatch, month));
        // 全月是否全部签到 true
    }
}

package com.hlj.util.Z005BitSet;

import org.junit.Test;

import java.util.Arrays;
import java.util.BitSet;

/**
 * BitSet的应用场景  海量数据去重、排序、压缩存储
 * BitSet的基本操作   and（与）、or（或）、xor（异或）
 * Bitset，也就是位图，由于可以用非常紧凑的格式来表示给定范围的连续数据而经常出现在各种算法设计中。
 * 基本原理是，用1位来表示一个数据是否出现过，0为没有出现过，1表示出现过。使用用的时候既可根据某一个是否为0表示此数是否出现过。
 */
public class D01BitSet {

    /**
     * 给定一个的整数数组，请找到其中缺少的数字。
     */
    private void printMissingNumber(int[] numbers, int count) {
        System.out.println("一共有" + count + "个数据：目前数组为" + Arrays.toString(numbers));
        // 一共有10个数据：目前数组为[1, 2, 3, 4, 6, 9, 8]


        // 一共有多少数字,
        BitSet bitSet = new BitSet(count);
        // 将指定索引处的位设置为 true。
        for (int number : numbers) {
            bitSet.set(number - 1);
        }


        //一共丢失了多少位
        int missingCount = count - numbers.length;
        int lastMissingIndex = 0; // 索引从0开始
        for (int i = 0; i < missingCount; i++) {
            //返回第一个设置为 false 的位的索引，这发生在指定的起始索引或之后的索引上。
            lastMissingIndex = bitSet.nextClearBit(lastMissingIndex);
            System.out.println(++lastMissingIndex);
        }
    }

    @Test
    public void start() {
        // 丢失3个数据
        printMissingNumber(new int[]{1, 2, 3, 4, 6, 9, 8}, 10);

        // 丢失1个数据
        printMissingNumber(new int[]{1, 2, 3, 5}, 5);

    }

}

@Test
public void test() {
    // 创建两个 RoaringBitmap 实例
    RoaringBitmap bitmap1 = new RoaringBitmap();
    RoaringBitmap bitmap2 = new RoaringBitmap();

    // 向 bitmap1 添加元素
    bitmap1.add(1);
    bitmap1.add(100);
    bitmap1.add(1000);

    // 向 bitmap2 添加元素
    bitmap2.add(100);
    bitmap2.add(200);
    bitmap2.add(1000);


    // 执行交集操作
    RoaringBitmap intersection = RoaringBitmap.and(bitmap1, bitmap2);
    System.out.println("Intersection: " + intersection); // 应该包含 100 和 1000
    // Intersection: {100,1000}

    // 执行差集操作 (bitmap1 - bitmap2)
    RoaringBitmap difference = RoaringBitmap.andNot(bitmap1, bitmap2);
    System.out.println("Difference (bitmap1 - bitmap2): " + difference); // 应该只包含 1
    // Difference (bitmap1 - bitmap2): {1}

    // 检查元素是否存在
    boolean contains100 = bitmap1.contains(100);
    System.out.println("Does bitmap1 contain 100? " + contains100); // 输出 true
    // Does bitmap1 contain 100? true

    // 输出 bitmap1 的内容
    System.out.println("Bitmap1: " + bitmap1);
    // Bitmap1: {1,100,1000}
}

@Test
public void testSizeOfBitMap() {

    //对比占用空间大小 - 10w元素
    RoaringBitmap roaringBitmap3 = new RoaringBitmap();
    byte[] bits2 = new byte[100000];
    for (int i = 0; i < 100000; i++) {
            roaringBitmap3.add(i);
            bits2[i] = (byte) i;
    }
    System.out.println("10w数据 roaringbitmap byte size:"+ roaringBitmap3.getSizeInBytes());
    System.out.println("10w数据 位图数组 byte size:"+bits2.length);

    RoaringBitmap roaringBitmap4 = new RoaringBitmap();
    byte[] bits3 = new byte[1000000];
    for (int i = 0; i < 1000000; i++) {
        roaringBitmap4.add(i);
        bits3[i] = (byte) i;
    }
    System.out.println("100w数据 roaringbitmap byte size:"+ roaringBitmap4.getSizeInBytes());
    System.out.println("100w数据 位图数组 byte size:"+bits3.length);

    RoaringBitmap roaringBitmap5 = new RoaringBitmap();
    byte[] bits4 = new byte[10000000];
    for (int i = 0; i < 10000000; i++) {
        roaringBitmap5.add(i);
        bits4[i] = (byte) i;
    }
    System.out.println("1000w数据 roaringbitmap byte size:"+ roaringBitmap5.getSizeInBytes());
    System.out.println("1000w数据 位图数组 byte size:"+bits4.length);
}

@Test
public void testSize() {
    RoaringBitmap roaringBitmap5 = new RoaringBitmap();
    byte[] bits4 = new byte[10000000];
    for (int i = 0; i < 10000000; i++) {
        if (i == 1 || i == 9999999) {
            roaringBitmap5.add(i);
            bits4[i] = (byte) i;
        }
    }
    System.out.println("两个稀疏数据 roaringbitmap byte size:"+ roaringBitmap5.getSizeInBytes());
    System.out.println("两个稀疏数据 位图数组 byte size:"+bits4.length);
}

public class ArrayContainer {

    public byte[] values;

    public ArrayContainer(int initialCapacity) {
        this.values = new byte[initialCapacity];
    }
}

package com.hlj.util.Z005BiMap.模拟bitMap;

/**
 * CompressedBitmap
 *
 * @author zhangyujin
 * @date 2024/9/14
 */
public class CompressedBitmap {

    /**
     * 表示“是”或“已设置”，即该位为1
     */
    public static final char Y = 1;

    /**
     * 表示“否”或“未设置”，即该位为0
     */
    public static final char N = 0;

    /**
     * 每个“容器”负责管理 16 个 bit 位。这是分片的基础单位。
     */
    public static final int ARRAY_CONTAINER_SIZE = 16;

    /**
     * 容器数组，每个元素是一个ArrayContainer对象
     */
    ArrayContainer[] containers;


    /**
     * 初始化容量：根据传入的 initialCapacity（最大可表示的位数），计算需要多少个容器。
     *
     *
     * @param initialCapacity initialCapacity
     * @return {@link }
     */
    public CompressedBitmap(long initialCapacity) {
        // 每个容器管 16 个位，所以总共需要 initialCapacity / 16 个容器，不考虑向上去整
        int containersSize = (int) (initialCapacity / ARRAY_CONTAINER_SIZE);
        // 创建一个 ArrayContainer 类型的数组，初始时所有元素为 null（延迟初始化，节省内存）。
        this.containers = new ArrayContainer[containersSize];
    }

    /**
     * bitMap添加数据
     *
     * @param offset offset
     */
    public void add(long offset) {
        // 1、根据偏移量定位容器所在分片
        int shardIndex = getShardIndex(offset);
        ArrayContainer container = containers[shardIndex];
        if (container == null) {
            container = new ArrayContainer(ARRAY_CONTAINER_SIZE);
        }

        // 2、根据偏移量定位容器内部位置
        int shardOffset = getShardOffset(offset);
        container.values[shardOffset] = Y;
        containers[shardIndex] = container;
    }


    /**
     * 获取偏移量数据
     *
     * @param offset offset
     * @return 获取值（1 || 0）
     */
    public int get(long offset) {
        int shardIndex = getShardIndex(offset);
        ArrayContainer container = containers[shardIndex];
        if (container == null) {
            return N;
        }

        int shardOffset = getShardOffset(offset);
        if (Y == container.values[shardOffset]) {
            return Y;
        }
        return N;
    }

    /**
     * 计算 offset 属于第几个容器/分片。
     *
     * @param offset offset
     * @return {@link int}
     */
    public int getShardIndex(long offset) {
        //  offset 是从 1 开始计数的！比如：offset=1~16 → 索引 0；offset=17~32 → 索引 1，等等。
        return (int) ((offset - 1) / ARRAY_CONTAINER_SIZE);
    }

    /**
     * 根据偏移量定位容器内部位置
     *
     * @param offset offset
     * @return {@link int}
     */
    public int getShardOffset(long offset) {
        return (int) ((offset - 1) % ARRAY_CONTAINER_SIZE);
    }


}

@Test
public void test(){
    CompressedBitmap bitmap = new CompressedBitmap(64);
    bitmap.add(63);
    System.out.println(bitmap.get(63));
    // 1
    System.out.println(bitmap.get(64));
    // 0
    System.out.println(bitmap.get(2));
    // 0
}

// 方案1：业务分片 (high-key 隔离)
int shard = (int)(userId % 256); // 256 个分片
Roaring64NavigableMap[] shards = new Roaring64NavigableMap[256];

// 方案2：Long-to-Int 映射 (随机 ID 场景)
Map<Long, Integer> idMapper = new Caffeine.newBuilder()
    .maximumSize(100_000_000)
    .build();
RoaringBitmap compactSet = new RoaringBitmap(); // 仅用 32 位版

public class ShardedRoaringSet {
    private final int shardCount = 256;
    private final Roaring64NavigableMap[] shards = new Roaring64NavigableMap[shardCount];
    
    public void add(long value) {
        int shard = (int)(value % shardCount); // 业务相关分片
        if (shards[shard] == null) {
            shards[shard] = new Roaring64NavigableMap();
        }
        shards[shard].add(value);
        
        // 防御性检查：单分片 high-key > 4000 时告警
        if (shardHighKeyCount(shard) > 4000) {
            triggerCompaction(shard); // 后台压缩或迁移
        }
    }
}

// 步骤1: 建立全局映射 (存储在Redis/LevelDB)
Map<Long, Integer> globalIdMap = new OffHeapMap(); // 使用堆外存储

// 步骤2: 转换后使用 32 位 RoaringBitmap
RoaringBitmap usersInExperiment = new RoaringBitmap();
for (Long userId : rawUserIds) {
    int compactId = globalIdMap.computeIfAbsent(userId, k -> assignNewId());
    usersInExperiment.add(compactId);
}

// 步骤3: 查询时反向转换
for (Integer compactId : usersInExperiment) {
    Long originalId = globalIdMap.reverseLookup(compactId);
    // 处理业务逻辑
}

// Roaring64NavigableMap 独有功能
Roaring64NavigableMap bitmap = new Roaring64NavigableMap();
bitmap.add(100L);
bitmap.add(200L);

// 范围导航 (Roaring64Bitmap无法高效实现)
long after150 = bitmap.higher(150); // 返回200
long last = bitmap.last(); // 返回200

// 范围视图
NavigableMap<Long, RoaringBitmap> subrange = bitmap.subMap(50L, true, 150L, true); // [100]

@Data
public class CompressedBitInfo {

    /**
     * 真实offset
     */
    private long sourceOffset;

    /**
     * 分桶的编号
     */
    private long bucketIndex;

    /**
     * 桶内的offset
     */
    private long bucketOffset;

    /**
     * key
     */
    private String bitKey;

    /**
     * bitValue
     */
    private Boolean bitValue;

}

@Data
public class CompressedBizBO {

    /**
     * key
     */
    private String key;

    /**
     * 过期时间
     */
    private Integer expireSeconds;

    /**
     * 桶大小
     */
    private Long bucketSize;

}

@Slf4j
public class CompressedBitUtils {

    /**
     * 设置压缩位图在offset上的值,并且设置过期时间(秒)
     */
    public static CompressedBitInfo setCompressedBit(CompressedEnum.CompressedInfoEnum compressedInfoEnum, 
                                                     long offset) {
        return setCompressedBit(compressedInfoEnum, offset, true);
    }



    /**
     * 删除压缩位图在offset上的值(相当于设置为false)
     */
    public static CompressedBitInfo remCompressedBit(CompressedEnum.CompressedInfoEnum compressedInfoEnum, 
                                                     long offset) {
        return setCompressedBit(compressedInfoEnum, offset, false);
    }


    /**
     * 设置压缩位图在offset上的值,并且设置过期时间(秒)
     */
    public static CompressedBitInfo setCompressedBit(CompressedEnum.CompressedInfoEnum compressedInfoEnum, 
                                                     long offset, 
                                                     boolean value) {
        FilterCompressedConfiguration filterCompressedConfiguration = SpringUtils.getBean(FilterCompressedConfiguration.class);
        CompressedBizBO compressedBiz = filterCompressedConfiguration.getCompressedBizMap().get(compressedInfoEnum.getCode());

        CompressedBitInfo bitInfo = getBitInfo(compressedInfoEnum, offset);
        String bitKey = bitInfo.getBitKey();
        RedisService redisService = SpringUtils.getBean(RedisService.class);
        redisService.setBit(bitKey, bitInfo.getBucketOffset(), value);
        redisService.expire(bitKey, compressedBiz.getExpireSeconds());

        long sourceOffset = getSourceOffset(compressedInfoEnum, bitInfo.getBucketIndex(), bitInfo.getBucketOffset());
        bitInfo.setSourceOffset(sourceOffset);
        bitInfo.setBitValue(value);

        return bitInfo;
    }
    /**
     * 获取压缩位图在offset上的值
     */
    public static CompressedBitInfo getCompressedBit(CompressedEnum.CompressedInfoEnum compressedInfoEnum, long offset) {
        CompressedBitInfo bitInfo = getBitInfo(compressedInfoEnum, offset);
        String bitKey = bitInfo.getBitKey();
        log.debug("getCompressedBit with key:{}, offset:{}", bitKey, bitInfo.getBucketOffset());
        RedisService redisService = SpringUtils.getBean(RedisService.class);
        Boolean bitValue = redisService.getBit(bitKey, bitInfo.getBucketOffset());
        long sourceOffset = getSourceOffset(compressedInfoEnum, bitInfo.getBucketIndex(), bitInfo.getBucketOffset());
        bitInfo.setSourceOffset(sourceOffset);
        bitInfo.setBitValue(bitValue);
        return bitInfo;
    }

    /**
     * 获取压缩位图每个小桶的子key集合
     */
    public static List<String> getAllBucketKeys(CompressedEnum.CompressedInfoEnum compressedInfoEnum, long maxOffset) {
        List<String> result = Lists.newArrayList();
        FilterCompressedConfiguration filterCompressedConfiguration = SpringUtils.getBean(FilterCompressedConfiguration.class);
        CompressedBizBO compressedBiz = filterCompressedConfiguration.getCompressedBizMap().get(compressedInfoEnum.getCode());

        CompressedBitInfo bitInfo = getBitInfo(compressedInfoEnum, maxOffset);
        for (int i = 0; i <= bitInfo.getBucketIndex(); i++) {
            String bitKey = getBitKey(compressedBiz.getKey(), i);
            result.add(bitKey);
        }
        return result;
    }

    /**
     * 删除所有桶里的的Bitmap
     */
    public static void deleteAllCompressedBit(CompressedEnum.CompressedInfoEnum compressedInfoEnum, long maxOffset) {
        FilterCompressedConfiguration filterCompressedConfiguration = SpringUtils.getBean(FilterCompressedConfiguration.class);
        CompressedBizBO compressedBiz = filterCompressedConfiguration.getCompressedBizMap().get(compressedInfoEnum.getCode());

        CompressedBitInfo bitInfo = getBitInfo(compressedInfoEnum, maxOffset);
        for (int i = 0; i < bitInfo.getBucketIndex(); i++) {
            String bitKey = getBitKey(compressedBiz.getKey(), i);
            RedisService redisService = SpringUtils.getBean(RedisService.class);
            redisService.expire(bitKey, 0);
        }
    }


    /**
     * 将java中的bitmap转换为redis的字节数组
     */
    private static byte[] getByteArray(List<Long> bits) {
        Iterator<Long> iterator = bits.iterator();
        BitSet bitSet = new BitSet();
        while (iterator.hasNext()) {
            long offset = iterator.next();
            bitSet.set((int) offset);
        }
        byte[] targetBitmap = bitSet.toByteArray();
        convertJavaToRedisBitmap(targetBitmap);
        return targetBitmap;
    }

    /**
     * 将java中的字节数组转换为redis的bitmap数据形式
     *
     * @param bytes
     */
    private static void convertJavaToRedisBitmap(byte[] bytes) {
        int len = bytes.length;
        for (int i = 0; i < len; i++) {
            byte b1 = bytes[i];
            if (b1 == 0) {
                continue;
            }
            byte transByte = 0;
            for (byte j = 0; j < 8; j++) {
                transByte |= (b1 & (1 << j)) >> j << (7 - j);
            }
            bytes[i] = transByte;
        }
    }


    /**
     * getBitInfo
     */
    public static CompressedBitInfo getBitInfo(CompressedEnum.CompressedInfoEnum compressedInfoEnum, long sourceOffset) {
        FilterCompressedConfiguration filterCompressedConfiguration = SpringUtils.getBean(FilterCompressedConfiguration.class);
        CompressedBizBO compressedBiz = filterCompressedConfiguration.getCompressedBizMap().get(compressedInfoEnum.getCode());

        CompressedBitInfo bucketInfo = new CompressedBitInfo();
        bucketInfo.setSourceOffset(sourceOffset);

        long bucketSize = compressedBiz.getBucketSize();
        long bucketIndex = sourceOffset / bucketSize;
        bucketInfo.setBucketIndex(bucketIndex);

        long bucketOffset = sourceOffset % bucketSize;
        bucketInfo.setBucketOffset(bucketOffset);

        String bitKey = getBitKey(compressedBiz.getKey(), bucketIndex);
        bucketInfo.setBitKey(bitKey);
        return bucketInfo;
    }


    public static String getBitKey(String key, long bucketIndex) {
        return new StringBuffer(key).append("_").append(bucketIndex).toString();
    }

    /**
     * getSourceOffset
     *
     * @param bucketIndex  bucketIndex
     * @param bucketIndex  bucketIndex
     * @param bucketOffset bucketOffset
     * @return {@link long}
     */
    public static long getSourceOffset(CompressedEnum.CompressedInfoEnum compressedInfoEnum, long bucketIndex, long bucketOffset) {
        FilterCompressedConfiguration filterCompressedConfiguration = SpringUtils.getBean(FilterCompressedConfiguration.class);
        CompressedBizBO compressedBiz = filterCompressedConfiguration.getCompressedBizMap().get(compressedInfoEnum.getCode());
        return bucketIndex * compressedBiz.getBucketSize() + bucketOffset;
    }
}

public interface CompressedEnum {


    /**
     * CompressedKeyEnum
     */
    @Getter
    @AllArgsConstructor
    enum CompressedInfoEnum implements CompressedEnum {

        DEFAULT("default", "默认"),
        ;

        /**
         * key
         */
        private final String code;


        /**
         * 描述
         */
        private final String desc;
    }
}

@Slf4j
@Data
@Configuration
@ConfigurationProperties("filter")
public class FilterCompressedConfiguration {


    /**
     * 压缩过滤器配置
     */
    private Map<String, CompressedBizBO> compressedBizMap;

}

/**
 * 将java中的bitmap转换为redis的字节数组
 *
 */
private byte[] getByteArray(List<Long> bits) {
    Iterator<Long> iterator = bits.iterator();
    BitSet bitSet = new BitSet();
    while (iterator.hasNext()) {
        long offset = iterator.next();
        bitSet.set((int) offset);
    }
    byte[] targetBitmap = bitSet.toByteArray();
    convertJavaToRedisBitmap(targetBitmap);
    return targetBitmap;
}

/**
 * 将java中的字节数组转换为redis的bitmap数据形式
 *
 * @param bytes
 */
private static void convertJavaToRedisBitmap(byte[] bytes) {
    int len = bytes.length;
    for (int i = 0; i < len; i++) {
        byte b1 = bytes[i];
        if (b1 == 0) {
            continue;
        }
        byte transByte = 0;
        for (byte j = 0; j < 8; j++) {
            transByte |= (b1 & (1 << j)) >> j << (7 - j);
        }
        bytes[i] = transByte;
    }
}