java - 位屏蔽无符号和有符号值

Question

在示例中provided here ,

We created a 64 bit ID that contains the shard ID = 16 bit, the type of the containing data = 10 bit, and where this data is in the table (local ID) = 36.

The savvy additionology experts out there will notice that only adds to 62 bits. My past in compiler and chip design has taught me that reserve bits are worth their weight in gold. So we have two (set to zero).

这是否意味着:

问题一:

它们可以有 2^16，范围为 0-65536 分片？

类型 ID 为 2^10，范围为 0-1024 类型？

本地 ID 为 2^36，范围为 0-68719476736 本地 ID？

我还尝试在 Java 中复制他们的哈希函数

|表示两组 32 位的分离，以便更容易可视化。

#表示移位46位​​，包含18位，其中2位保留-ShardId

~ 表示位移 36 位，包含 10 位 - 类型 ID剩余的36位-本地ID:

#0000 0000 0000 0000 00#~00 0000 0000~ 0000 | 0000 0000 0000 0000 0000 0000 0000 0000 |

<小时/>

1. ShardID 3429 的二进制 = 1101 0110 0101
2. 因此 (hashedValue >> 46) = 00 0000 1101 0110 0101&
3. 0xFFFF = 1111 1111 1111 1111
4. ShardId = 00 0000 1101 0110 0101

问题二:

我理解 1. 和 2 的需要。但是我不明白为什么我们需要按位运算符 & 0xFFFF，因为 4 和 2 实际上是相同的。

问题三:

我收到以下编译器错误:int 类型的文字 0xFFFFFFFFF 超出范围

public class BitExampleTest {
    public static void main(String[] args) {
      long pinId = 241294492511762325L;
      unHash(pinId);
    }

    private static long hash(int shardId, int typeId, int localId){
        return (shardId << 46) | (typeId << 36) | (localId << 0);
    }

    private static void unHash(long hashedValue){
               long shardID = (hashedValue >> 46) & 0xFFFF; 
               long typeID  = (hashedValue >> 36) & 0x3FF;
               long localID = (hashedValue >>  0) & 0xFFFFFFFFF;

               System.out.printf("shardID %s \n",shardID);
               System.out.printf("typeID %s \n",typeID);
               System.out.printf("localID %s \n",localID);
    }
}

Answer 1

They can have 2^16, range of 0-65536 shards?

分片 ID 为 16 位。因此，可能有 2¹⁶ 个不同的分片 ID。

Type ID of 2^10, range of 0-1024 types?

类型 ID 为 10 位。因此，可能有 2¹⁰ 种不同的类型 ID。

Local ID of 2^36, range of 0-68719476736 local id's?

本地ID是36位。因此，可能有 2³⁶ 个不同的本地 ID，即可能有指向表中 2³⁶ 个位置的指针。

现在，引用Pinterest post ，用于演示的 Pin ID 为 241294492511762325。

乍一看，很明显该值不适合 Java int 数据类型。因此，我们切换到long。

// 'L' added to tell the compiler it is a long, not an int
System.out.println(Long.toBinaryString(241294492511762325L)); 

// output (padded with 0's on the left)
0000 0011 0101 1001 0100 0000 0001 0000 0000 0000 0110 1011 1111 0111 1001 0101

最初，241294492511762325 的 ID 看起来像这样...

xx 00 0011 0101 1001 01 00 0000 0001 0000 0000 0000 0110 1011 1111 0111 1001 0101
XX [____SHARD(16)_____] [_TYPE(10)_] [________________LOCAL(36)_________________]

要获取分片位，将 ID 右移 (10 + 36) 46 即可。这会让我们。请注意，XX 左边的位可以是 0 或 1，具体取决于“最后两位”的符号扩展等。

xx 00 0011 0101 1001 01
XX [____SHARD(16)_____]

将其与 0xffff 进行按位与

           'our 2 golden bits'
                   ▼▼
  xxxx xxxx xxxx xxxx 0000 1101 0110 0101
& 0000 0000 0000 0000 1111 1111 1111 1111
= 0000 0000 0000 0000 0000 1101 0110 0101

无论前导位设置为何，现在它们都是 0。我认为这应该让您清楚，与 0xffff 进行按位 AND 背后的原因。如果它们的左侧填充了 0，那就太好了。如果不是，AND 会处理它。 :)

当你初始化像 0xFFFFFFFFF 这样的文字时，如果没有后缀并且变量是整型(int、long 等)，则该值被假定为 int。而且，int 可以容纳 32 位，而不是像您尝试的那样 36 位(9 x 0xF = 9 x '1111')。因此，您必须使用容量为 64 位的 long。将“L”或“l”附加到值的末尾(例如 0xFFFFFFFFFL)应该可以解决编译器错误。 [Reference ]