Java中的字节数组

Java字节数组仅用于存储字节数据类型值。字节数组中元素的默认值为0。

通过以下Java字节数组示例，您可以学习

• 如何声明Java字节数组？
• 如何为Java字节数组分配值？
• 如何从Java字节数组获取值？
• 如何在Java中将String转换为字节数组？
• 如何在Java中将字节数组转换为字符串？

什么是字节？

一组二进制数字或位（通常是八个）作为一个单元进行操作。一个字节，视为内存大小的单位。

字节是数字信息的单位，通常由八位组成。从历史上看，字节是计算机中用于编码文本的单个字符的位数，因此，它是许多计算机体系结构中最小的可寻址存储单元。

字节是一个数据测量单位，它包含八个位或一系列八个零和一。一个字节可用于表示2个8或256个不同的值。

字节在Java中是什么意思？

字节是Java中原始数据类型之一。这意味着Java字节的大小与计算机内存中的字节相同：它是8位，并且可以保存-128到127的值。字节数据类型以Java编程语言打包提供，无需特殊操作即可使其工作。

字节数组是什么意思？

字节为8位（二进制数据）。

字节数组是字节数组。

您可以使用字节数组来存储二进制数据的集合，例如文件的内容。不利之处是必须将整个文件内容加载到内存中。

Java中一个字节多少位？

该字节在Java中等于8位。

byte是Java中的关键字吗？

字节是Java中的关键字，它指定8位带符号整数基元类型。

标准Java整数数据类型以字节为单位：

• 字节1字节-128至127
• 短2字节-32768至32767
• int 4字节-2147483648至2147483647
• 长8字节-9223372036854775808至9223372036854775807

如何在Java中声明字节数组？

数组用[]声明（方括号）。如果将[]（方括号）放在任何类型的任何变量之后，则仅该变量属于数组类型，而该声明中的其余变量不是属于该类型普通变量的数组变量。

如果将[]（方括号）放在任何数据类型之后，则该声明中的所有变量都是数组变量。数组中的所有元素都可以通过index访问。数组元素索引从0到n-1个数字开始，即，如果数组有5个元素，则开始索引为0，结束索引为4。

// Java bytearray
//声明字节数组
byte [] byteArray;

如何在Java中初始化（init）字节数组（byte []）？

分配字节数组时，会将其初始化（init）为0。Java中的所有数组都初始化为type的默认值。这意味着将整数数组初始化为0，将布尔数组初始化为false，将引用类型数组初始化为null。

如何初始化字节数组示例

// Java bytearray
//如何在Java
byte []中初始化字节数组或byte [] byteArray = new byte [10];

Java中字节数组的初始值或默认值是多少？

字节数组的初始值为0。因为Java中字节数据类型的默认值为0。

Java中字节数组的长度是多少？

长度是Java中数组对象的属性，它返回给定数组中元素的数量。

Java中字节数组的最大长度是多少？

Java中字节数组的最大长度为2147483647。您最多可以存储2147483647个元素。

Java中数组的长度是多少？

在Java中，所有数组仅由int索引和声明。那就是数组的大小必须由一个int值指定，而不是long或short。所有数组索引从0开始到2147483646结束。您最多可以存储2147483647个元素。如果尝试将长（大）元素存储在数组中，则会遇到性能问题。如果您克服了性能问题，则应使用Java集合框架或简单地使用Vector。

句法 ：

在Java字节数组示例中，您可以学习如何在声明时将值分配给Java字节数组。

在Java字节数组示例之后，您可以学习如何使用其他Java字节数组变量声明Java字节数组。

在Java字节数组示例之后，您可以学习如何将Java字节数组分配给其他Java字节数组。

Java将字符串转换为字节[]

我们可以通过两种方式将String转换为byte []。

1. 通过使用String.getBytes（）方法
2. 通过在Java 8中使用Base64类

如何在Java中将String转换为字节数组？

若要从String转换为字节数组，请使用String.getBytes（）方法。请注意，此方法使用平台的默认字符集。

我们可以使用String类的getBytes（）方法使用平台的默认charset将字符串编码为字节序列。此方法已重载，我们也可以将Charset作为参数传递。

以下程序显示了如何在java中将String转换为字节数组。

如何在Java 8中将String转换为字节数组？

要在Java 8中从String转换为字节数组，请使用Base64.getDecoder（）。decode（）方法。Base64.getDecoder（）。decode（）方法将字符串转换为字节数组。Base64类自Java 1.8开始，因此此代码在Java 1.8之前不起作用。

以下程序显示了如何在Java 8中将String转换为字节数组。

如何在Java中将字节数组转换为字符串？

我们可以通过两种方式将字节数组转换为String。

1. 没有字符编码。
2. 具有字符编码。
3. 通过在Java 8中使用Base64类

如何在不使用字符编码的Java中将字节数组转换为字符串？

我们甚至可以不指定字符编码就将字节数组转换为String。只需将字节数组传递给String构造函数即可。

如何在Java中使用字符编码将字节数组转换为字符串？

我们可以使用UTF-8字符编码将字节数组转换为String。

如何在Java 8中将字节数组转换为String？

要将Java 8中的字节数组转换为String，请使用Base64.getEncoder（）。encodeToString（）方法。Base64.getEncoder（）。encodeToString（）方法将字节数组转换为String。Base64类自Java 1.8开始，因此此代码在Java 1.8之前不起作用。

以下程序显示了如何在Java 8中将字节数组转换为String。

Java中的ByteBuffer是什么？

字节缓冲区可以是direct或non-direct。给定直接字节缓冲区，Java虚拟机将尽最大努力直接在其上执行本机I / O操作。也就是说，它将尝试避免在每次调用底层操作系统的本机I / O操作之前（或之后）将缓冲区的内容复制到中间缓冲区（或从中间缓冲区复制）。

java.nio.ByteBuffer类的allocate（）方法用于分配新的字节缓冲区。

新缓冲区的位置将为零，其极限将是其容量，其标记将是未定义的，并且其每个元素都将初始化为零。它将有一个支持数组，并且其数组偏移量将为零。

如何将Java整数转换为字节数组？

我们将讨论将int转换为字节数组的各种方法。在java int中，数据类型占用4个字节（32位），范围是-2147483648至2147483647。

您可以使用Java NIO的ByteBuffer将Java整数转换为字节数组，这非常简单。下面的示例演示如何将Java整数转换为字节Array。

如何将Java字节数组转换为long？

Java提供了ByteBuffer类来做同样的事情。要转换任何字节数组，首先需要使用ByteBuffer的静态方法allocate分配8个字节，然后使用put方法放置byteArray并通过调用getLong（）方法翻转字节缓冲区，我们可以获取该字节数组的long值。

您可以使用Java NIO的ByteBuffer将Java字节数组转换为long，这非常简单。

如何在Java中将对象转换为字节数组？

1. 通过实现Serializable接口使所需的对象可序列化。
2. 创建一个ByteArrayOutputStream对象。
3. 通过传递在上一步中创建的ByteArrayOutputStream对象来创建ObjectOutputStream对象。
4. 使用ObjectOutputStream类的writeObject（）方法将对象的内容写入输出流。
5. 使用flush（）方法将内容刷新到流中。
6. 最后，使用toByteArray（）方法将ByteArrayOutputStream的内容转换为字节数组。

下面的示例演示如何将对象转换为字节数组。准备要发送的字节数组：

如何使用Java将byte []（数组）转换为文件？

“ hello” .getBytes（）; 使用平台的默认字符集将给定的String编码为字节序列，该字符集将结果存储到新的byte数组中。

new File（“ c：\\ demo.txt”）通过将给定的路径名​​字符串转换为抽象路径名来创建一个新的File实例。

new FileOutputStream（file）创建一个文件输出流，以写入指定File对象表示的文件。

os.write（bytes）将指定字节数组中的字节数写入输出stream。

下面的示例演示如何将byte []（数组）转换为File。

Java中的byte详解

介绍

byte，即字节，由8位的二进制组成。在Java中，byte类型的数据是8位带符号的二进制数。

在计算机中，8位带符号二进制数的取值范围是[-128, 127]，所以在Java中，byte类型的取值范围也是[-128, 127]。

byte取值范围分析

一直在想为什么不是 -128 到 128呢？今天分析了一下这个问题。

首先我们得明白一件事情，那就是运算规则(因为计算机中的数是以反码形式存储的，反码再求反码得到该数真值)：

正数的最高位都是 0 ，正数的值就是二进制表示的值。

负数的最高位都是 1 ，负数的值是 取反后加一 然后加个负号得到得值。

我们用8位的二进制来说明一下此规则：

比如：00000001。最高位是0 为正数 ，那么表示的就是 十进制的 1。

再比如：10000001.最高位是1 为负数，值是多少？取反得到 01111110 加1 得到 01111111 ，那么值为 -127 (可能你会有疑问了？why？-127不是应该是1111 1111，先不急，可以去看下面要说的 反码，你就懂了)

理解此运算规则我们正式开始说byte，byte正好是8位的二进制数。short是16位 int是32位 long是64位。

不难理解，byte的最大正数就是 01111111（最高位必须是0），也就是 127。

那么你可能会想 byte的最小负数就是 11111111 了，对不对? 这么想就

大错特错了。让我们看看11111111这个二进制数表示多少。

根据上面的提示 我们知道这是一个负数。它的值是先取反再加1 。

11111111取反得到：00000000，加1得到 00000001 。最后得到的值为-1.

这可是最大的负数啊。由此你是不是想到了最小的负数会不会是10000000呢？

让我们算一下 取反：01111111 加1得到 10000000 最后得到 -128.

127是01111111 然而 -128是10000000 ，看出来一个奇怪的事情。

仔细的看一下这两个二进制数 是不是前者加1就得到后者呢？对。

可以编一个小程序实验一下：

byte a = 127; 
a+=1; 
System.out.println(a);

结果正好是-128

由此我们可以看出来二进制从 00000000 到01111111到10000000到 11111111

即 十进制从 0 到 127 到 -128 到 -1。

接下来，我们用一段代码来更深刻地理解byte：

public class A {
 public static void main(String[] args) {
  int b = 456;
  byte test = (byte) b;
  System.out.println(test);
 }
}

上述代码，最后会输出-56。原因如下：

456的二进制表示是111001000，由于int是32位的二进制，所以在计算机中，实际上是00000000000……111001000，当int转成byte的时候，那么计算机会只保留最后8位，即11001000。

然后11001000的最高位是1，那么表示是一个负数，而负数在计算机中都是以补码的形式保存的，所以我们计算11001000的原码为00111000，即56，所以11001000表示的是-56，所以最后test的值为-56。

byte\short\int\long

java中存储的数据类型均带符号,即看最高位:为0表示正数,为1表示负数

原码\反码\补码

原码：就是二进制码，最高位为符号位，0表示正数，1表示负数，剩余部分表示真值。

反码：在原码的基础上，正数反码就是他本身，负数除符号位之外全部按位取 反。

补码：正数的补码就是自己本身， 负数的补码是在自身反码的基础上加1.

逻辑运算符

包含: &（与）, | （或）, ^ （异或），~ （按位取反）

& :当2个都为1的时候为1， 其他都是0 。 1&1 = 1， 1&0 = 0， 0&0 = 0； 他的作用是清0

| : 当2个只要有一个为1，就是1. 1|0 = 1; 0|0 = 0, 1|1 = 1;

^: 相同为0， 不相同为1， 1^0 = 1, 1^1 = 0, 0^0 = 0; 他的作用是定位翻转。

~: 按位取反，0变为1， 1变为0；

之所以要明确原码，反码，补码，是因为java中变量都是以补码的形式保存的。

比如 整行30 他的原码是：0001 1110. 正数，所以反码，补码都是0001 1110.

对于负数：-7 ，他的原码是 1000 0111， 第一位1表示是此数是负数。他的反码是：1111 1000, 补码在反码的基础上加1， 所以它的补码是1111 1001， 所以他的二进制数就是1111 1001.

如“-16+11”的运算：

11110000     + -16的补码
00001011       11的补码
————
11111011       - 5的补码

移位操作符

包含:<<, >>, >>>

<< 表示左移，不分正负数，丢去高位,低位补0,如果移动的位数大于32， 那么就需要取余(例如下方<<10等价于<<2)

注：以下数据类型默认为byte-8位

左移时不管正负，低位补0

正数：r = 20 << 2

20的二进制补码：0001 0100

向左移动两位后：0101 0000

结果：r = 80

负数：r = -20 << 2

-20 的二进制原码 ：1001 0100

-20 的二进制反码 ***：*1110 1011

-20 的二进制补码 ：1110 1100

左移两位后的补码：1011 0000

反码：1010 1111

原码：1101 0000

结果：r = -80

>>表示右移，如果该数为正，则高位补0，若为负数，则高位补1

注：以下数据类型默认为byte-8位

正数：r = 20 >> 2

20的二进制补码：0001 0100

向右移动两位后：0000 0101

结果：r = 5

负数：r = -20 >> 2

-20 的二进制原码 ：1001 0100

-20 的二进制反码 ：1110 1011

-20 的二进制补码 ：1110 1100

右移两位后的补码：1111 1011

反码：1111 1010

原码：1000 0101

结果：r = -5

>>>表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0

正数：　r = 20 >>> 2

的结果与 r = 20 >> 2 相同；

负数：　r = -20 >>> 2

注：以下数据类型默认为int 32位

-20:源码：10000000 00000000 00000000 00010100

反码：11111111 11111111 11111111 11101011

补码：11111111 11111111 11111111 11101100

右移：00111111 11111111 11111111 11111011

结果：r = 1073741819

大小端模式

大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。

小端模式，是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。

下面以unsigned int value = 0x12345678为例，分别看看在两种字节序下其存储情况，我们可以用unsigned char buf[4]来表示value

Big-Endian: 低地址存放高位，如下：
高地址

​ buf[3] (0x78) – 低位
​ buf[2] (0x56)
​ buf[1] (0x34)
​ buf[0] (0x12) – 高位

​ 低地址
Little-Endian: 低地址存放低位，如下：
​ 高地址

​ buf[3] (0x12) – 高位
　　buf[2] (0x34)
　　buf[1] (0x56)
　　buf[0] (0x78) – 低位

​ 低地址

int与byte[]相互转换

  /**
     * int到byte[] 由高位到低位
     * @param i 需要转换为byte数组的整行值。
     * @return byte数组
     */
    public static byte[] intToByteArray(int i) {
        byte[] result = new byte[4];
        result[0] = (byte)((i >> 24) & 0xFF);
        result[1] = (byte)((i >> 16) & 0xFF);
        result[2] = (byte)((i >> 8) & 0xFF);
        result[3] = (byte)(i & 0xFF);
        return result;
    }
 
    /**
     * byte[]转int
     * @param bytes 需要转换成int的数组
     * @return int值
     */
    public static int byteArrayToInt(byte[] bytes) {
        int value=0;
        for(int i = 0; i < 4; i++) {
            int shift= (3-i) * 8;
            value +=(bytes[i] & 0xFF) << shift;
        }
        return value;
    }

注意事项

c语言中数据类型分为有符号数和无符号数,但是在java中只有有符号数,不存在无符号数.所以当我们与硬件人员共同开发项目时,解析协议里面的byte[]要注意跟硬件人员确定是否带符号.带符号就跟java中一样处理即可.不带符号的话就要小心了,如果还按照java常规方法解析可能会越界.所以一般我们在byte[]转int值时,当作byte[]转long处理即可;在int转byte[]时,当作long转byte[],然后截取后4个字节(大端模式转换)

c++ 基本类型与byte 数组互相转换

前言

	由于根据编译器的不同 有部分基础数据类型字节数不一致
	本文档 基础类型位数如下
		bool 字节数： 1
		char 字节数： 1
		short 字节数： 2
		int 字节数： 4
		long 字节数： 4
		long long 字节数： 8
		float 字节数： 4
		double 字节数： 8
		long double 字节数： 12

说明

传统C方式  位操作： 使用一个unsigned int变量来作为位容器。
	强制指针类型转换。
由于C++ 中没有Bety 类型  所以  typedef  unsigned char byte;

INT 与 byte数组互转

    /**
    * convert int type to  byte array
    */
    static void  intToByte(int i, byte* bytes);


    /**
    * convert byte array to int type
    */
    static int bytesToInt(byte* bytes);

void ByteUtil::intToByte(int i, byte* bytes)
{


   size_t length = sizeof(int);
	// 初始化数组
    memset(bytes, 0, sizeof(byte) * length);
    bytes[0] = (byte)(0xff & i);
    bytes[1] = (byte)((0xff00 & i) >> 8);
    bytes[2] = (byte)((0xff0000 & i) >> 16);
    bytes[3] = (byte)((0xff000000 & i) >> 24);
    return;
}

int ByteUtil::bytesToInt(byte* bytes)
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    int addr = bytes[0] & 0xFF;
    addr |= ((bytes[1] << 8) & 0xFF00);
    addr |= ((bytes[2] << 16) & 0xFF0000);
    addr |= ((bytes[3] << 24) & 0xFF000000);
    return addr;
}

long与 byte数组互转

    /**
    * convert long type to  byte array
    */
    static void  longToByte( long i, byte* bytes);


    /**
    * convert byte array to long type
    */
    static long bytesToLong(byte* bytes);


void ByteUtil::longToByte(long i, byte *bytes)
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    size_t length = sizeof(long);
    memset(bytes, 0, sizeof(byte) * length);
    bytes[0] = (byte)(0xff & i);
    bytes[1] = (byte)((0xff00 & i) >> 8);
    bytes[2] = (byte)((0xff0000 & i) >> 16);
    bytes[3] = (byte)((0xff000000 & i) >> 24);
}

long ByteUtil::bytesToLong(byte *bytes)
{
    
    // 位操作时 使用一个unsigned int变量来作为位容器。
     long addr = bytes[0] & 0xFF;
    addr |= ((bytes[1] << 8) & 0xFF00);
    addr |= ((bytes[2] << 16) & 0xFF0000);
    addr |= ((bytes[3] << 24) & 0xFF000000);
    
    return addr;
}

LONG LONG 与 byte数组互转

    /**
    * convert long long type to  byte array
    */
    static void  longLongToByte( long long i, byte* bytes);


    /**
    * convert byte array to long long type
    */
    static long long bytesToLongLong(byte* bytes);



void ByteUtil::longLongToByte(long long i, byte* bytes)
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    size_t length = sizeof(long long);
    memset(bytes, 0, sizeof(byte) * length);
    bytes[0] = (byte)(0xff & i);
    bytes[1] = (byte)((0xff00 & i) >> 8);
    bytes[2] = (byte)((0xff0000 & i) >> 16);
    bytes[3] = (byte)((0xff000000 & i) >> 24);
    bytes[4] = (byte)((0xff00000000 & i) >> 32);
    bytes[5] = (byte)((0xff0000000000 & i) >> 40);
    bytes[6] = (byte)((0xff000000000000 & i) >> 48);
    bytes[7] = (byte)((0xff00000000000000 & i) >> 56);
}

long long ByteUtil::bytesToLongLong(byte* bytes)
{

    // 位操作时 使用一个unsigned int变量来作为位容器。
    long long addr = bytes[0] & 0xFF;
    addr |= ((bytes[1] << 8) & 0xFF00);
    addr |= ((bytes[2] << 16) & 0xFF0000);
    addr |= ((bytes[3] << 24) & 0xFF000000);
    addr |= ((((long long) bytes[4]) << 32) & 0xFF00000000);
    addr |= ((((long long) bytes[5]) << 40) & 0xFF0000000000);
    addr |= ((((long long) bytes[6]) << 48) & 0xFF000000000000);
    addr |= ((((long long) bytes[7]) << 56) & 0xFF00000000000000);
    return addr;
}

short 与 byte数组互转

 /**
    * convert Short type to  byte array
    */
    static void  shortToByte(short i, byte* bytes);


    /**
    * convert byte array to Short type
    */
    static short bytesToShort(byte* bytes);


void ByteUtil::shortToByte(short i, byte* bytes)
{

    // 位操作时 使用一个unsigned int变量来作为位容器。
     size_t length = sizeof(short);

    //byte[] bytes = new byte[4];
    memset(bytes, 0, sizeof(byte) * length);
    bytes[0] = (byte)(0xff & i);
    bytes[1] = (byte)((0xff00 & i) >> 8);
    return;


}

short ByteUtil::bytesToShort(byte* bytes)
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    short addr = bytes[0] & 0xFF;
    addr |= ((bytes[1] << 8) & 0xFF00);
    return addr;
}

double 与 byte数组互转

/**
    * convert byte array to double type
    */
    static double bytesToDouble(byte bytes[]);

    /**
    *  c++ double type length is 8 byte
    *	 convert  double type to byte array
    */
    static void doubleTobytes(double data, byte bytes[]);


double ByteUtil::bytesToDouble(byte bytes[])
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    double data = *((double*)bytes);
    return data;
}

void ByteUtil::doubleTobytes(double data, byte bytes[])
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    int i;

    size_t length = sizeof(double);

    char* p = (char*)&data;
    for (i = 0; i < length; i++)
    {
        bytes[i] = *p++;
    }
}

long double 与 byte数组互转

  /**
    * convert byte array to double type
    */
    static long double bytesToLongDouble(byte bytes[]);

    /**
    *  c++ double type length is 8 byte
    *	 convert  long double type to byte array
    */
    static void longDoubleTobytes(long double data, byte bytes[]);


long double ByteUtil::bytesToLongDouble(byte bytes[])
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
   long double data = *((long double *)bytes);
   return data;
}

void ByteUtil::longDoubleTobytes(long double data, byte bytes[])
{

    // 位操作时 使用一个unsigned int变量来作为位容器。
    int i;

    size_t length = sizeof(long double);

    char* p = (char*)&data;
    for (i = 0; i < length; i++)
    {
        bytes[i] = *p++;
    }

}

float 与 byte数组互转

 /**
    * convert byte array to float  type
    * C语言可用
    */
    static float  bytesToFloat(byte bytes[]);

    /**
    *	 convert  float type to byte array
    */
    static void floatTobytes(float  data, byte bytes[]);


float RKByteUtil::bytesToFloat(byte bytes[])
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    return *((float*)bytes);

}

void RKByteUtil::floatTobytes(float data, byte bytes[])
{
    // 位操作时 使用一个unsigned int变量来作为位容器。
    int i;
    size_t length = sizeof(float);


    byte *pdata = (byte*)&data; //把float类型的指针强制转换为unsigned char型
    for (i = 0; i < length; i++)
    {
        bytes[i] = *pdata++;//把相应地址中的数据保存到unsigned char数组中
    }
    return;
}

bool与 byte数组互转

    /**
    * convert byte array to bool  type
    * C语言可用
    */
    static bool  bytesToBool(byte bytes[]);

    /**
    *
    *	 convert  bool type to byte array
    */
    static void boolTobytes(bool  data, byte bytes[]);



bool ByteUtil::bytesToBool(byte bytes[])
{
    return (bytes[0] & 0x01) == 1 ? true : false;
}

void ByteUtil::boolTobytes(bool data, byte bytes[])
{

    if (data) {
        bytes[0] = (byte)(0x01 & 1);
    }
    else {
        bytes[0] = (byte)(0x01 & 0);
    }

}