关于数字存储和byte[]数组的一些心得

前言

最近做项目,发现一些规律,比如数字的存储和字符串的存储,先说数字吧,最常见的整数,就涉及反码和补码,根据这些规则,甚至我们自己也能造一种数据存储结构,比如1个字节8bit,在byte里面就是一半正数一半负数,但是在二进制却是我们不理解的一种方式。计算机存储都是字节存储,字符实际上也是字节,那么byte[]数组在很多时候就很关键,比如grpc算法那一期:grpc Java demo与Springboot改造支持grpc通信_grpc-client-spring-boot-starter-CSDN博客

准备demo

demo解说

比如byte 127表示01111111,byte是8bit,所以有一个符号位,但是负数呢

-128就是10000000,这里转int了,4个字节而byte是一个字节,实际上byte=字节,就是直译的

那么我们把int强转为byte呢

这就涉及数据的存储了,计算机不能运算减法,使用加法做减法,那么负数就需要一种表现形式,即符号位,但是bit2进制存储,并不是我们理解的存储方式,这就涉及反码和补码了,数据以补码的形式存储。

原码、反码、补码

数据都是2进制存储,计算机为了做减法,对每个字节的从左到右第一个bit定义为符号位,为什么从左到右,实际上在看UTF-16的编码设计,就有高位和低位的说法,真难懂,字节byte的第一bit为符号位定义清晰。

原码

原码是使用数据本身的定义存储,即符号位1bit,其他是我们真实的数据,非常符合我们的认知。

|-----|-----------|-----|-----------|
| 正整数 | 二进制原码 | 负整数 | 二进制原码 |
| 1 | 0000 0001 | -1 | 1000 0001 |
| 2 | 0000 0010 | -2 | 1000 0010 |
| 3 | 0000 0011 | -3 | 1000 0011 |
| 4 | 0000 0100 | -4 | 1000 0100 |
| 5 | 0000 0101 | -5 | 1000 0101 |

但是原码有个问题:1+ (-1) ≠ 0,这是不允许的。

反码

既然原码1 + (-1) ≠ 0那么,按位取反,就可以了,表示负数

整数的反码与原码一致,负数的反码是除了符号bit,其余bit位按位取反,毕竟反码就是为负数做加法设计的。但是因为负数是按位取反,所以1+(-1) ≠ 0。

|-----|-----------|-----|-----------|
| 正整数 | 二进制反码 | 负整数 | 二进制反码 |
| 1 | 0000 0001 | -1 | 1111 1110 |
| 2 | 0000 0010 | -2 | 1111 1101 |
| 3 | 0000 0011 | -3 | 1111 1100 |
| 4 | 0000 0100 | -4 | 1111 1011 |
| 5 | 0000 0101 | -5 | 1111 1010 |

补码

负数除了符号位按位取反后,虽然语义清晰了,但是做加法运算仍然是有问题的:

1+(-1)≠ 0,这就需要补码了

正数的原码、反码、补码一致;负数的补码=反码+1bit

|-----|-----------|-----|-----------|
| 正整数 | 二进制补码 | 负整数 | 二进制补码 |
| 1 | 0000 0001 | -1 | 1111 1111 |
| 2 | 0000 0010 | -2 | 1111 1110 |
| 3 | 0000 0011 | -3 | 1111 1101 |
| 4 | 0000 0100 | -4 | 1111 1100 |
| 5 | 0000 0101 | -5 | 1111 1011 |

实际上数据就是补码存储的,但是每个字节做加法也有问题

1+(-1) = 1 0000 0000

就是超限了,计算机就把超限的bit位舍弃,来达到1+(-1)=0的计算,所以-1就是1111 1111了,但是对于byte来说-128呢,毕竟0111 1111 = 127,即一个字节,所以-128没有原码,当然也没有反码了,只有补码,毕竟0这个特殊的数据,不存在+0和-0的说法。

-128原码= 1 1000 0000 超限byte了,byte只有8bit,去掉符号位只有7位,即原码最大-127

-128反码= 1 0111 1111 原码没有就没有反码了

-128补码= 1 1000 0000 补码

说说0

-0的原码=1 000 0000

-0的反码=1 111 1111

-0的补码=0 000 0000 = +0

神奇的设计。

byte[]数组

那么byte[]数组呢,奇特的地方是每个byte是-128~127,但是多个字节时只有开始的一个bit是符号位,对于多个字节的整个bit位是遵循补码存储的思路,但是对于单个字节就会出现负数表示255的情况。

可以看到255刚好够一个byte存储,转为byte看看

-1,相当于-1表示255,128表示-128

相当于考虑符号位和多字节不考虑字节本身符号位的表示规则:

127后是-128,然后依次递增+1,知道255=-1

当然,int转byte[]就涉及高低位顺序了,类似utf-16编码。

上次grpc的算法

grpc Java demo与Springboot改造支持grpc通信_grpc-client-spring-boot-starter-CSDN博客

java 复制代码
package org.springframework.http.converter.protobuf;
 
public class LengthBytesUtils {
    public static byte[] intToBytes(int length, int size) {
        byte[] bytes = new byte[size];
        int temp;
        for (int i = size - 1; i > -1; i--) {
            temp = (int) ((length / (Math.pow(253, (size - 1 - i)))) % 253);
            if (temp > 127) {
                temp = -128 + 1 + temp - 127 + 1;
            }
            bytes[i] = (byte) temp;
        }
        return bytes;
    }
 
    public static int bytesToInt(byte[] bytes) {
        int length = 0;
        int size = bytes.length;
        for (int i = 0; i < size; i++) {
            if (bytes[i] == 0){
                continue;
            }
            if (bytes[i] > 0) {
                length += bytes[i] * Math.pow(253, size-1-i);
            } else {
                length += (127-1 + bytes[i] + 128-1) * Math.pow(253, size-1-i);
            }
        }
        return length;
    }
}

实际上是剔除了一些byte数据表示,但是grpc把长度从int的4字节提升到5字节,相当于创造了一种正整数 数据类型,实际上可以优化为

java 复制代码
    public static byte[] intToBytes2(int length, int size) {
        byte[] bytes = new byte[size];
        int temp;
        for (int i = size - 1; i > -1; i--) {
            temp = (byte) ((length / (Math.pow(253, (size - 1 - i)))) % 253);
            if (temp < 0) {
                temp = 3 + temp;
            }
            bytes[i] = (byte) temp;
        }
        return bytes;
    }

    public static int bytesToInt2(byte[] bytes) {
        int length = 0;
        int size = bytes.length;
        for (int i = 0; i < size; i++) {
            if (bytes[i] == 0) {
                continue;
            }
            if (bytes[i] > 0) {
                length += bytes[i] * Math.pow(253, size - 1 - i);
            } else {
                length += (bytes[i] + 253) * Math.pow(253, size - 1 - i);
            }
        }
        return length;
    }

因为int转byte,符号位生效,byte会认为第一个bit是符号位,但是对int的字节数组的每个字节就不一定了,只有最高位bit是符号位,其他都是数据位

int 4个字节

0 0000000 00000000 00000000 10000000 = int 128 = byte[]{0, 0, 0, -128}

但是byte -128转int还是-128,因为是向上转型,是byte类型一定是int类型,反之则不对。

总结

实际上这次是一些碎碎念,核心还是计算机的原理,计算机因为电气性能只设计有0、1,所以是2进制,存算都是2进制。而且计算机在设计之初只设计了加法,没设计或者设计减法有问题,导致数据相减运算都是加运算,所以需要存储和运算负数,那么就需要定义负数的存储和相加逻辑,就设计了反码和补码来存储负数。

另外一个字节存储能力有限,往往需要很多字节来存储一个内容,那么符号位的定义在总体结构很明晰,但是对于字节数组的单个字节就会存在歧义,造成数据可读性很迷惑,因为符号位的特殊意义。同时,我们可以根据需要自定义数据类型,但是字节数组存储会有读取顺序的高低位问题,类似UTF-16编码的左右读取模式。

相关推荐
Daniel 大东36 分钟前
BugJson因为json格式问题OOM怎么办
java·安全
Ajiang28247353042 小时前
对于C++中stack和queue的认识以及priority_queue的模拟实现
开发语言·c++
盼海2 小时前
排序算法(五)--归并排序
数据结构·算法·排序算法
幽兰的天空2 小时前
Python 中的模式匹配:深入了解 match 语句
开发语言·python
Theodore_10225 小时前
4 设计模式原则之接口隔离原则
java·开发语言·设计模式·java-ee·接口隔离原则·javaee
冰帝海岸6 小时前
01-spring security认证笔记
java·笔记·spring
世间万物皆对象6 小时前
Spring Boot核心概念:日志管理
java·spring boot·单元测试
没书读了7 小时前
ssm框架-spring-spring声明式事务
java·数据库·spring
----云烟----7 小时前
QT中QString类的各种使用
开发语言·qt
lsx2024067 小时前
SQL SELECT 语句:基础与进阶应用
开发语言