Java 函数，该函数返回存储长值所需的字节数

我创建了一个函数，返回存储长值所需的字节数。该值必须在

[Long.MIN\u值，Long.MAX\u值]中。

private static final int ONE_BYTE_MAX = (1 << 7) - 1; // 127

---

private static final int ONE_BYTE_MAX=（1将
Long
转换为
二进制字符串
，然后获取
字符串的
长度

public static int getNbBytesForLongValue(long value) {
    int length = Long.toBinaryString(value).length();
    int noOfByte = length%8 == 0 ? length/8 : (length/8 + 1);
    return noOfByte;
}

注意：负数存储为2的补充。因此，
-10
将存储为
1111111111111111111111111111110110
。因此，您将获得
8
作为输出（这是正确的）代替
2
将
Long
转换为
二进制字符串
，然后获取
字符串的
长度

public static int getNbBytesForLongValue(long value) {
    int length = Long.toBinaryString(value).length();
    int noOfByte = length%8 == 0 ? length/8 : (length/8 + 1);
    return noOfByte;
}

注意：负数存储为2的补充。因此，
-10
将存储为
1111111111111111111111111111110110
。因此，您将获得
8
作为输出（这是正确的）您可以创建一个包含两个字段的枚举，而不是
2
。然后迭代该枚举值，循环中只有一个if语句：

public enum Range {

    ONE  (1, -(1L << 7 ), (1L << 7 ) - 1),
    TWO  (2, -(1L << 15), (1L << 15) - 1),
    THREE(3, -(1L << 23), (1L << 23) - 1),
    FOUR (4, -(1L << 31), (1L << 31) - 1),
    FIVE (5, -(1L << 39), (1L << 39) - 1),
    SIX  (6, -(1L << 47), (1L << 47) - 1),
    SEVEN(7, -(1L << 55), (1L << 55) - 1);

    public final int bytesNeeded;
    public final long min;
    public final long max;

    Range(int bytesNeeded, long min, long max) {
        this.bytesNeeded = bytesNeeded;
        this.min = min;
        this.max = max;
    }

    public static int getNbBytesForLongValue(long value) {
        for (Range range : Range.values()) {
            if (range.min <= value && value <= range.max) {
                return range.bytesNeeded;
            }
        }
        return 8;
    }

}

公共枚举范围{
一（1，-（1L您可以创建一个包含两个字段的枚举：min和max。然后迭代该枚举值，循环中只有一个if语句：

public enum Range {

    ONE  (1, -(1L << 7 ), (1L << 7 ) - 1),
    TWO  (2, -(1L << 15), (1L << 15) - 1),
    THREE(3, -(1L << 23), (1L << 23) - 1),
    FOUR (4, -(1L << 31), (1L << 31) - 1),
    FIVE (5, -(1L << 39), (1L << 39) - 1),
    SIX  (6, -(1L << 47), (1L << 47) - 1),
    SEVEN(7, -(1L << 55), (1L << 55) - 1);

    public final int bytesNeeded;
    public final long min;
    public final long max;

    Range(int bytesNeeded, long min, long max) {
        this.bytesNeeded = bytesNeeded;
        this.min = min;
        this.max = max;
    }

    public static int getNbBytesForLongValue(long value) {
        for (Range range : Range.values()) {
            if (range.min <= value && value <= range.max) {
                return range.bytesNeeded;
            }
        }
        return 8;
    }

}

公共枚举范围{
一（1，-（1L您可以使用
for
循环将参数除以128，然后计算达到0所需的i操作数

public int countBytesNeeded(long l) {
    if (l == 0) {
        return 1;
    }

    int result = 0;

    for (; l != 0; result++) {
        l = l / 128;
    }
    return result;
}

您可以使用
for
循环将参数除以128，然后计算达到0所需的i操作数

public int countBytesNeeded(long l) {
    if (l == 0) {
        return 1;
    }

    int result = 0;

    for (; l != 0; result++) {
        l = l / 128;
    }
    return result;
}

您需要找到最高的1位，然后才能知道需要多少字节

该方法可用于此目的

由于long具有
long.SIZE
位（实际上是64位），因此很容易计算，但需要对零值和负值进行特殊处理

public static int getNbBytesForLongValue1(long value) {
    if (value == 0)
        return 1;
    int bitLength;
    if (value > 0) {
        int leadingZeroes = Long.numberOfLeadingZeros(value);
        bitLength = Long.SIZE - leadingZeroes + 1/*positive sign bit*/;
    } else {
        int leadingOnes = Long.numberOfLeadingZeros(value ^ -1L);
        bitLength = Long.SIZE - leadingOnes + 1/*negative sign bit*/;
    }
    return (bitLength + 7) / 8; // round up to whole bytes
}

可以将其缩短为（如果您想显得有点模糊）：

解决方案只需一行代码，不需要循环。
您需要找到最高的1位，然后您就知道需要多少字节

该方法可用于此目的

由于long具有
long.SIZE
位（实际上是64位），因此很容易计算，但需要对零值和负值进行特殊处理

public static int getNbBytesForLongValue1(long value) {
    if (value == 0)
        return 1;
    int bitLength;
    if (value > 0) {
        int leadingZeroes = Long.numberOfLeadingZeros(value);
        bitLength = Long.SIZE - leadingZeroes + 1/*positive sign bit*/;
    } else {
        int leadingOnes = Long.numberOfLeadingZeros(value ^ -1L);
        bitLength = Long.SIZE - leadingOnes + 1/*negative sign bit*/;
    }
    return (bitLength + 7) / 8; // round up to whole bytes
}

可以将其缩短为（如果您想显得有点模糊）：

解决方案只需一行代码，不需要循环。
在这个答案中，我们重点关注所需的位数。从这里开始，字节数可以通过ceil除以8来计算

int bytesNeeded(long number) {
    return (bitsNeeded(number) + 7) / 8;
}

我假设我们将所有数字存储在2的补码中，因此我们需要5位而不是4位来存储数字8dec=01000bin，以此类推

对于适合
long
对于更大的数字
如果您对较大的数字感兴趣，可以将它们存储在
biginger
中。幸运的是，
biginger
为您提供了一种非常方便的方法：

int bitsNeeded(BigInteger number) {
     return number.bitLength() + 1;
}

如果您不关心大数字，但想使用
bitLength（）
use

int bitsNeeded(long number) {
     return BigInteger.valueOf(number).bitLength() + 1;
}

在这个答案中，我们将重点放在所需的位数上。从这里开始，字节数可以通过ceil除以8来计算

int bytesNeeded(long number) {
    return (bitsNeeded(number) + 7) / 8;
}

我假设我们将所有数字存储在2的补码中，因此我们需要5位而不是4位来存储数字8dec=01000bin，以此类推

对于适合
long
对于更大的数字
如果您对较大的数字感兴趣，可以将它们存储在
biginger
中。幸运的是，
biginger
为您提供了一种非常方便的方法：

int bitsNeeded(BigInteger number) {
     return number.bitLength() + 1;
}

如果您不关心大数字，但想使用
bitLength（）
use

int bitsNeeded(long number) {
     return BigInteger.valueOf(number).bitLength() + 1;
}

虽然我认为在Java中，对于long原语类型，我们应该将字节数保留为8，但有另一种方法可以计算容纳long值的最小字节数（包括符号位）。此外，这种方法还可以用于计算调整方法签名的任何整数的大小：

public static int getMinNoOfBytes(BigInteger value)

然而，代码如下：

public class Answer {

    public static int getMinNoOfBytes(long value) {
        BigInteger any = BigInteger.valueOf(value);
        return any.toByteArray().length;
    }


    //Test
    public static void main(String[] args) {

        //Long.MAX_VALYE
        System.out.println(getMinNoOfBytes(Long.MAX_VALUE));

        //Long.MIN_VALUE
        System.out.println(getMinNoOfBytes(Long.MIN_VALUE));

        //Any value
        System.out.println(getMinNoOfBytes(65536));

    }
}

输出为（如预期的那样）

八,
8.
3
虽然我认为在Java中，对于long原语类型，字节数应该保留为8，但有另一种方法可以计算保存long值的最小字节数（包括符号位）。此外，这种方法还可以用于计算调整方法签名的任何整数的大小：

public static int getMinNoOfBytes(BigInteger value)

然而，代码如下：

public class Answer {

    public static int getMinNoOfBytes(long value) {
        BigInteger any = BigInteger.valueOf(value);
        return any.toByteArray().length;
    }


    //Test
    public static void main(String[] args) {

        //Long.MAX_VALYE
        System.out.println(getMinNoOfBytes(Long.MAX_VALUE));

        //Long.MIN_VALUE
        System.out.println(getMinNoOfBytes(Long.MIN_VALUE));

        //Any value
        System.out.println(getMinNoOfBytes(65536));

    }
}

输出为（如预期的那样）

八,
8.
3
您可以创建一个包含两个字段的枚举：min和max。然后对该枚举值进行迭代，循环中只有一个if语句。@JaroslawPawlak能否请您详细解释一下，顺便说一句，您实际执行的操作并不完全正确。所有负数的二进制表示形式都以1开头。请看一下2的Complement.2.
Long.SIZE
是一个常量，等于64。你可以创建一个包含两个字段的枚举：min和max。然后迭代该枚举值，在循环中只有一个if语句。@JaroslawPawlak你能不能简单地说，顺便说一句，你实际上所做的并不完全正确。所有负数在二进制表示中都以1开头。看看2的补码。简单地做一下
value.SIZE
？@umopapidn 1如何。
value
是一个原语，因此不起作用。2.
Long.SIZE
是一个常量，等于64.我认为缺少8的除法。对于
300
结果应该是2，而不是9。他需要字节，这将返回位。我认为这样做可以：
int length=Long.tobinarysting（value.length（）；返回长度/8+（长度%8>0？1:0）；
by