Lucene单值编码压缩算法源码解析

public final void writeVInt(int i) throws IOException {
  // 如果i的最低7位置0后i非0  
  while ((i & ~0x7F) != 0) {
    // i & 0x7F：取最低7位
    // | 0x80 为flag为置1
    writeByte((byte) ((i & 0x7F) | 0x80));
    // i 右移7位
    i >>>= 7;
  }
  // 剩下不足7位的  
  writeByte((byte) i);
}

public int readVInt() throws IOException {
  byte b = readByte();
  // 如果 b >= 0, 说明flag位是0，当前要读的值只有一个字节。  
  if (b >= 0) return b;
  int i = b & 0x7F;
  b = readByte();
  i |= (b & 0x7F) << 7;
  if (b >= 0) return i;
  b = readByte();
  i |= (b & 0x7F) << 14;
  if (b >= 0) return i;
  b = readByte();
  i |= (b & 0x7F) << 21;
  if (b >= 0) return i;
  b = readByte();
  // 最后一个字节最多只有4位是有效的
  i |= (b & 0x0F) << 28;
  // 如果最后一个字节只有低四位有效，则说明格式正确  
  if ((b & 0xF0) == 0) return i;
  throw new IOException("Invalid vInt detected (too many bits)");
}

public static int zigZagEncode(int i) {
  // (i >> 31)：处理符号位，把所有的位都设置为符号位，等待和0（数据位左移1位空出来的0）做异或，就能保留符号位在最后一位
  // (i << 1)：处理数据位，数据为左移1位，把最后一位用来存符号位，其他数据为都和符号位做异或编码
  return (i >> 31) ^ (i << 1);
}

public static int zigZagDecode(int i) {
  // (i >>> 1)：还原数据位，最后和符号位做异或解码
  // -(i & 1)：还原符号位，i的最后一位是符号位，该表达式把每一位都设置为符号位 
  return ((i >>> 1) ^ -(i & 1));
}

static void writeZFloat(DataOutput out, float f) throws IOException {
  int intVal = (int) f;
  final int floatBits = Float.floatToIntBits(f);
  // 为什么负数只对-1处理呢？原因是-1+1可以变成0
  // 为什么正数直到125呢，是因为第3个分支，会先写个标记byte：0xFF，所以不能包括126,126+1=127=0xFF会冲突
  if (f == intVal && intVal >= -1 && intVal <= 0x7D && floatBits != NEGATIVE_ZERO_FLOAT) {
    // 最高位是1表示这种情况
    out.writeByte((byte) (0x80 | (1 + intVal)));
  } else if ((floatBits >>> 31) == 0) { // 其他大于0的情况
    // 为什么不直接writeInt呢？我也不清楚，单独的lucene-core模块没有找到原因。
    out.writeByte((byte) (floatBits >> 24));
    out.writeShort((short) (floatBits >>> 8));
    out.writeByte((byte) floatBits);
  } else { // 其他小于0的情况
    out.writeByte((byte) 0xFF);
    out.writeInt(floatBits);
  }
}

static float readZFloat(DataInput in) throws IOException {
  // 先读取第一个字节，用来判断属于哪种情况  
  int b = in.readByte() & 0xFF;
  if (b == 0xFF) { // 情况3，后面还有4字节IEEE 754编码的float
    return Float.intBitsToFloat(in.readInt());
  } else if ((b & 0x80) != 0) { // 情况1
    // b & 0x7f：最高位设为0
    // -1 是因为编码的时候进行加1了  
    return (b & 0x7f) - 1;
  } else { // 情况2
    int bits = b << 24 | ((in.readShort() & 0xFFFF) << 8) | (in.readByte() & 0xFF);
    return Float.intBitsToFloat(bits);
  }
}

static void writeZDouble(DataOutput out, double d) throws IOException {
  int intVal = (int) d;
  final long doubleBits = Double.doubleToLongBits(d);
  // 因为多了一种情况，所以需要多一个标记，因此范围成了 [-1..124] 
  if (d == intVal && intVal >= -1 && intVal <= 0x7C && doubleBits != NEGATIVE_ZERO_DOUBLE) {
    out.writeByte((byte) (0x80 | (intVal + 1)));
    return;
  } else if (d == (float) d) { // 和zfloat相比，多出来的一种情况，使用标记：0xFE
    out.writeByte((byte) 0xFE);
    out.writeInt(Float.floatToIntBits((float) d));
  } else if ((doubleBits >>> 63) == 0) { // 同zfloat情况2
    out.writeByte((byte) (doubleBits >> 56));
    out.writeInt((int) (doubleBits >>> 24));
    out.writeShort((short) (doubleBits >>> 8));
    out.writeByte((byte) (doubleBits));
  } else { // 同zfloat情况3
    out.writeByte((byte) 0xFF);
    out.writeLong(doubleBits);
  }
}

static double readZDouble(DataInput in) throws IOException {
  int b = in.readByte() & 0xFF;
  if (b == 0xFF) {
    return Double.longBitsToDouble(in.readLong());
  } else if (b == 0xFE) {
    return Float.intBitsToFloat(in.readInt());
  } else if ((b & 0x80) != 0) {
    return (b & 0x7f) - 1;
  } else {
    long bits =
        ((long) b) << 56
            | ((in.readInt() & 0xFFFFFFFFL) << 24)
            | ((in.readShort() & 0xFFFFL) << 8)
            | (in.readByte() & 0xFFL);
    return Double.longBitsToDouble(bits);
  }
}

static void writeTLong(DataOutput out, long l) throws IOException {
  int header;
  if (l % SECOND != 0) { // 无压缩
    header = 0;
  } else if (l % DAY == 0) { // 按天粒度
    header = DAY_ENCODING;
    l /= DAY;
  } else if (l % HOUR == 0) { // 小时粒度
    header = HOUR_ENCODING;
    l /= HOUR;
  } else { // 秒粒度
    header = SECOND_ENCODING;
    l /= SECOND;
  }
  // 先按zigzag编码
  final long zigZagL = BitUtil.zigZagEncode(l);
  // zigzag编码的最后5位放在head的最后5位  
  header |= (zigZagL & 0x1F);
  final long upperBits = zigZagL >>> 5;
  if (upperBits != 0) { // 如果zigzag编码的值去除最后5位后非零，则header的第3位设置为1，表示后面还有数据
    header |= 0x20;
  }
  // 写入header  
  out.writeByte((byte) header);
  if (upperBits != 0) { // zigzag编码的值去除最后5位剩下的value使用VLong的方式编码
    out.writeVLong(upperBits);
  }
}

static long readTLong(DataInput in) throws IOException {
  // 读取header  
  int header = in.readByte() & 0xFF;
  // 取header最后5位
  long bits = header & 0x1F;
  if ((header & 0x20) != 0) { // 判断是否除了header之外后面还有数据
    // in.readVLong()：读取VLong编码的剩下数据
    // << 5： 左移5位，为header中的低5位留出空间
    // bits |=：bits是保存的是完整的数据 
    bits |= in.readVLong() << 5;
  }
  // 使用zigzag解码
  long l = BitUtil.zigZagDecode(bits);
  switch (header & DAY_ENCODING) { // 按照不同的编码，乘以相应的倍数还原时间戳
    case SECOND_ENCODING:
      l *= SECOND;
      break;
    case HOUR_ENCODING:
      l *= HOUR;
      break;
    case DAY_ENCODING:
      l *= DAY;
      break;
    case 0:
      break;
    default:
      throw new AssertionError();
  }
  return l;
}