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}
}

public class ArrayContainer {


    public byte[] values;

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

public class CompressedBitmap {

    public static final char Y = 1;

    public static final char N = 0;
    public static final int ARRAY_CONTAINER_SIZE = 16;

    ArrayContainer[] containers;


    /**
     * 初始化容量（计算容器数量，当前按照一个容器16进行拆分）
     *
     * @param initialCapacity initialCapacity
     * @return {@link }
     */
    public CompressedBitmap(long initialCapacity) {
        int containersSize = (int) (initialCapacity / ARRAY_CONTAINER_SIZE);
        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;
    }

    /**
     * 根据偏移量定位容器所在分片
     *
     * @param offset offset
     * @return {@link int}
     */
    public int getShardIndex(long offset) {
        return (int) ((offset - 1) / ARRAY_CONTAINER_SIZE);
    }

    /**
     * 根据偏移量定位容器内部位置
     *
     * @param offset offset
     * @return {@link int}
     */
    public int getShardOffset(long offset) {
        return (int) (offset % 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
}

@Data
public class CompressedBitInfo implements Serializable {

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

    /**
     * 分桶的编号
     */
    private long bucketIndex;
    /**
     * 桶内的offset
     */
    private long bucketOffset;

}

public class CompressedBitTookit {

    /**
     * 通大小
     */
    public static final long DEFAULT_BUCKET_SIZE = 65536L;

    public static CompressedBitInfo getBitInfo(long sourceOffset, long bucketSize) {
        CompressedBitInfo bucketInfo = new CompressedBitInfo();
        bucketInfo.setSourceOffset(sourceOffset);

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

        long bucketOffset = sourceOffset % bucketSize;
        bucketInfo.setBucketOffset(bucketOffset);
        return bucketInfo;
    }
    public static CompressedBitInfo getBitInfo(long sourceOffset) {
        return getBitInfo(sourceOffset, DEFAULT_BUCKET_SIZE);
    }

    public static long getSourceOffset(long bucketIndex, long bucketSize, long bucketOffset) {
        return bucketIndex * bucketSize + bucketOffset;
    }
    public static long getSourceOffset(long bucketIndex,  long bucketOffset) {
        return getSourceOffset(bucketIndex, DEFAULT_BUCKET_SIZE, bucketOffset);
    }

}

package com.hlj.util.Z005BiMap.redis实现压缩BitMap;

import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;

import java.util.BitSet;
import java.util.Iterator;
import java.util.List;

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

    /**
     * 设置压缩位图在offset上的值,并且设置过期时间(秒)
     *
     * @param key    位图的KEY
     * @param offset 写入位图的偏移量
     */
    public void setCompressedBit(String key, long offset, boolean value, int expireSeconds) {
        CompressedBitInfo bitInfo = CompressedBitTookit.getBitInfo(offset);
        String bitKey = getBitKey(key, bitInfo.getBucketIndex());
        // redis.setBit(bitKey, bitInfo.getBucketOffset(),value);
        // redis.expire(bitKey, expireSeconds);
    }


    /**
     * 设置压缩位图在offset上的值
     *
     * @param key    位图的KEY
     * @param offset 写入位图的偏移量
     */
    public void setCompressedBit(String key, long offset, boolean value) {
        CompressedBitInfo bitInfo = CompressedBitTookit.getBitInfo(offset);
        String bitKey = getBitKey(key, bitInfo.getBucketIndex());
        // redis.setBit(bitKey, bitInfo.getBucketOffset(),value);
    }


    /**
     * 设置压缩位图在offset上的值(相当于设置为true)
     *
     * @param key    位图的KEY
     * @param offset 写入位图的偏移量
     */
    public void setCompressedBit(String key, long offset) {
        this.setCompressedBit(key, offset, true);
    }


    /**
     * 删除压缩位图在offset上的值(相当于设置为false)
     *
     * @param key    位图的KEY
     * @param offset 写入位图的偏移量
     */
    public void remCompressedBit(String key, long offset) {
        this.setCompressedBit(key, offset, false);
    }


    /**
     * 获取压缩位图在offset上的值
     *
     * @param key    位图的KEY
     * @param offset 写入位图的偏移量
     * @return
     */
    public Boolean getCompressedBit(String key, long offset) {
        CompressedBitInfo bitInfo = CompressedBitTookit.getBitInfo(offset);
        String bitKey = getBitKey(key, bitInfo.getBucketIndex());
        log.debug("getCompressedBit with key:{}, offset:{}", bitKey, bitInfo.getBucketOffset());
        // return redis.getBit(bitKey, bitInfo.getBucketOffset());
        return null;
    }


    /**
     * 获取压缩位图每个小桶的子key集合
     *
     * @param key       位图的KEY
     * @param maxOffset 最大的offset
     * @return
     */
    public List<String> getAllBucketKeys(String key, long maxOffset) {
        List<String> result = Lists.newArrayList();
        CompressedBitInfo bitInfo = CompressedBitTookit.getBitInfo(maxOffset);
        for (int i = 0; i < bitInfo.getBucketIndex(); i++) {
            String bitKey = getBitKey(key, i);
            result.add(bitKey);
        }
        return result;
    }

    /**
     * 删除所有桶里的的Bitmap
     *
     * @param key       位图的KEY
     * @param maxOffset 最大的offset
     */
    public void deleteAllCompressedBit(String key, long maxOffset) {
        CompressedBitInfo bitInfo = CompressedBitTookit.getBitInfo(maxOffset);
        for (int i = 0; i < bitInfo.getBucketIndex(); i++) {
            String bitKey = getBitKey(key, i);
            // redis.expire(bitKey, 0);
        }
    }


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

}

/**
 * 将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;
    }
}