byte 订阅
字节(Byte )是计算机信息技术用于计量存储容量的一种计量单位,也表示一些计算机编程语言中的数据类型和语言字符 [1]  。一个位节存储8位无符号数,储存的数值范围为0-255。如同字元一样,字节型态的变数只需要用一个位元组(8位元)的内存空间储存 [1]  。 展开全文
字节(Byte )是计算机信息技术用于计量存储容量的一种计量单位,也表示一些计算机编程语言中的数据类型和语言字符 [1]  。一个位节存储8位无符号数,储存的数值范围为0-255。如同字元一样,字节型态的变数只需要用一个位元组(8位元)的内存空间储存 [1]  。
信息
外文名
Byte
定    义
相当于一个字符,8位=1字节
类    型
数字信息的单位
中文名
字节
学    科
计算机
简    写
B
字节简介
字节是二进制数据的单位。一个字节通常8位长。但是,一些老型号计算机结构使用不同的长度。为了避免混乱,在大多数国际文献中,使用词代替byte。在多数的计算机系统中,一个字节是一个8位长的数据单位,大多数的计算机用一个字节表示一个字符、数字或其他字符。一个字节也可以表示一系列二进制位。在一些计算机系统中,4 个字节代表一个字,这是计算机在执行指令时能够有效处理数据的单位。一些语言描述需要2个字节表示一个字符,这叫做双字节字符集。一些处理器能够处理双字节或单字节指令。字节通常简写为“B”,而位通常简写为小写“b”,计算机存储器的大小通常用字节来表示 [2]  。
收起全文
精华内容
下载资源
问答
  • Java的byte类型详解 万次阅读 多人点赞
    2020-03-04 00:12:24

    前言

    byte这个单词是Java八种基本数据类型之一字节的关键字,在计算机存储中以字节为单位,8位比特(bit)组成一个字节。
    为什么弄清楚byte这么重要呢?因为智能硬件的数据传输大部分协议都是按字节一位一位来解析的,对于字节的运算十分频繁,如果不对byte研究透彻,就很容易犯一些特别基础的错误。

    1.取值范围

    byte由8位bit组成,每个bit只能是0或者1,所以byte一共有2的8次方种可能,也就是256。

    这样来说byte的取值范围就应该是0~256了吧,但是在Java中有一点需要特别注意,除了boolean和char是无符号的,其余的基本数据类型都是有符号的。而符号要怎么表示的,答案就是用最高位来标识,0为正数,1为负数。

    若byte为正数,则其最大值为

    0111 1111 //转换为10进制,2^6+2^5+2^4+2^3+2^2+2^1+1=127
    

    若byte为负数,则其最大值为

    1111 1111 //-127
    

    故byte的取值范围是-127~127。

    但这个结论与我们在各种Java教程中看到的取值范围不吻合,byte的真正取值范围是

    -2^8~2^8-1 即是 -128~127
    

    这个多出来的-128是怎么用字节表示的呢,用下面代码打印出-128的二进制表示。

    byte b1 = -128;
    System.out.println(Integer.toBinaryString(b1));
    //结果
    11111111 11111111 11111111 10000000
    

    截取最后8位,所以-128的二进制表示为10000000,从表面上看就是-0。

    实际上我们将二进制1111 1111表示的数字打印出来也不是-127,而是-1,可用下面代码进行验证

     byte b1 = (byte) 0B11111111;
    System.out.println(b1);
    //结果
    -1
    

    出现这种情形是因为计算机用补码的方式存储数值,关于补码详细介绍可参考这篇文章

    简而言之就是,正数的补码是自身,而负数的补码则是其绝对值按位取反再加1

    要注意-128是不能用常规的方式转换成补码的,只是规定了10000000这个值用来表示-128。

    2.为何赋值时会经常报错?

    在编码过程中,经常会遇到给byte变量赋值时报错,提示的错误如下

    byte b1 = 0x8F;
    //报错提示
    Incompatible types
    Required:byte
    Found:int
    

    意思就是类型不兼容,需要的是byte型,但给的是int型。int型的数值范围比byte大,会导致大于127的值无法正常表示,所以会报错。解决报错的方法就是将等号右边的字面值强转为byte。

    byte b1 = (byte) 0x8F; //-113
    

    在Java中,所有整型字面值都是int型,所有小数都是double型

    在上述的错误中0x8F被当成int型,并且其未带负号,转换成10进制为143。而byte的取值范围是-128~127,明显小于143,数值超出了byte的最大值,所以编辑器会报错,只能用强转的方式将int的最后8位截取掉变成byte类型。

    对byte的赋值几乎都是采用16进制表示的,如上述的0x8F,在很多情况下byte类型的变量并不是想看其十进制的值,而是想知道每一个bit的值,用二进制表示显得过长,而用16进制表示一个byte只需要两位即可,每一位表示4个bit。

    什么情况下byte的赋值会报错提示类型不对呢?那就是当数值大于127,换句话说就是byte的最高位为1时,在16进制里面就是当第1位大于7时就会报错。

    byte b1 = 0x7F; //不报错,无须强转
    byte b2 = 0x80; //报错,必须要强转
    

    3.基本四则运算注意点

    首先来看一个byte运算的例子

    byte b1 = 0x20;
    byte b2 = 0x10;
    byte b3 = b1 - b2; //报错
    //正确 byte b3 = byte(b1-b2);
    

    我们会发现最后一句代码报错,提示也是类型不兼容,需要的是byte,而给的int。从表面上看b1-b2的值为16,绝对没有超过127,为何也会报错呢?

    原因就在于Java的运算机制,在Java中两个变量只要参与了数学运算,就有可能会进行类型提升,只要类型比int小(即byte,char,short),那么在运算之前,这些值会自动转换成int。

    通常表达式中出现的最大的数据类型决定了表达式最终结果的数据类型。如果将一个float值与一个double值相乘,结果就是double,如果将一个int和一个long值相加,则结果为long。

    用byte运算要注意,如果结果的类型也是byte,有可能会发生负数运算后成正数,正数运算后变成负数的情况。看下面的例子:

    byte b4 = (byte) 0xA1;
    byte b5 = (byte) (b4*2);
    System.out.println("b4="+b4+",b5="+b5);
    //结果
    b4=-95,b5=66
    
    byte b6 = 0x46;//十进制为70
    b6*=2; //预期结果应为140
    System.out.println("b6="+b6);
    //结果
    b6=-116
    

    b4值为-95,乘以2得到-190,因为运算时会转换成int类型,-190的二进制为

    1111 1111 1111 1111 1111 1111 0100 0010
    

    再对-190进行强转,截取最后8位变成byte,最后结果的二进制为

    0100 0010  //66
    

    b6的值为0x46,转换成十进制为70,乘以2结果为140,二进制表示为

    00000000 00000000 00000000 10001100
    

    强转后结果为1000 1100,由于最高位是1,则说明值已经是个负数了。可怎么看起来这个值不像是-116的,而应该像-12的。这就涉及到补码了,这个二进制只是在计算机中的存储表示,要经过转换方能得到真值。转换过程如下:

    • 最高符号位不变,其余位全部取反,得到1111 0011
    • 再加1,得到1111 0100
    • 符号位不计算,其余7位转换为10进制的值是 64+32+16+4=116
    • 再加上负号,最终结果为-116。

    最后结论是用byte运算并且结果也是byte时要注意结果的符号可能会翻转,当计算的值大于127或者是小于-127时符号就会翻转,翻转后的值与真正的值两者的绝对值之和必定是256。

    4.位操作运算

    Java中的位操作有4种,分别是与&,或|,非~,异或^,位操作就是指对每一个bit进行操作,操作时将数据用二进制表示会更加直观,下面是位操作的运算规则说明。

    操作符值1值2结果
    &010
    |011
    ~NA10
    ^011

    byte类型在位操作运算时都会转成int类型,运算的结果也是int类型。

    在许多通信协议中会看到最后一位字节是校验位,校验值也分为很多算法,常见的有求和与异或校验,假如求和的值超过了byte的最大值,这种情况下会造成校验不准吗?

    答案是不会,假设在C中计算的校验和是unsigned char类型,累加校验值假定为200,转换成二进制就是11001000。在Java中计算时,因为byte会转换成int类型,所以计算的结果200用二进制表示就是

    00000000 00000000 00000000 11001000
    

    强转成byte为1100 1000,十进制为-56,虽然看起来和C中的值符号不一致,但在二进制中两者的每一位都是相同的,实际上两者在Java中就是相等的,所以累加和之类的校验可以计算出前几位的和并强转成byte之后直接与最后一位的校验值比较是否相等。

    虽然校验值可以不用转换直接对比,但是其他的数据字节计算就需要转换了。最常见的就是单片机用串口发送不了浮点数据过来,只能发一个字节的整型,所以普遍的做法就是发两个字节代表浮点数,高位与低位,计算公式为

    (高位字节*256 + 低位)/100
    

    很明显这个高低位字节在C中就是无符号char,是不会出现负数的。

    假如需要发送599.21的浮点值,那么高位值就为0xEA,低位值为0x11,在Java中用这个公式计算得到的结果却是一个负数。

    b1 = (byte) 0xEA;
    b2 = 0x11;
    float f1 =( b1 * 256 + b2)/100F;
    System.out.println("f1="+f1);
    //结果
    f1=-56.15
    

    在这种情况下,高位和低位的字节都必须先转换成正数再去进行计算。Java中的byte转换成正数的方式如下。

    b1 = (byte) 0xEA;
    System.out.println("b1="+b1);
    int i1 = b1 & 0xFF;
    System.out.println("i1="+i1);
    //结果
    b1=-22
    i1=234
    

    切忌使用b1&=0xFF这种方式进行转换,byte想要转换成正数必须要提升类型,所以这里使用了int类型来保存与0xFF位与运算后的结果。

    用这种转换方法再来计算一遍上述的浮点值,就能得到正确的结果

    b1 = (byte) 0xEA;
    b2 = 0x11;
    float f1 =( (b1&0xFF) * 256 + (b2&0xFF))/100F;
    System.out.println("f1="+f1);
    //结果
    f1=599.21
    

    在串口通信中,还有另外一种操作是经常使用的,那就是取某几个bit的值,这就需要用到移位操作了。

    假如有一个字节为0x9A,需要取最高两位的值,取值方法如下:

    //0B1001 0110 最高位为10,值应为2
    b1 = (byte) 0x96;
    b1 = (byte) ((b1 & 0xFF)>>6);
    System.out.println("b1="+b1);
    //结果
    b1=2
    

    在移位之前一定要跟0xFF相与转成正数,避免在移位时有1的值移到前8位里面造成结果错误。

    注:称位操作在Java中有3种,

    • 左移<<,低位补零
    • 右移>>,若符号为正则在高位插入0,符号为负则在高位插入1
    • 无符号右移>>>,无论正负,都在高位插入0
    更多相关内容
  • android byte字节数组转换十六进制字符串一个demo。里面有几种转换测试代码。我的博客地址:http://blog.csdn.net/qq_16064871。
  • Java字节数组byte b[]与byte[] b

    万次阅读 2020-12-25 15:16:06
    Java字节数组示例 /* Java byte Array Example Save with file name ByteArray.java */ public class ByteArray { public static void main(String args[]) { //JAVA BYTE ARRAY DECLARATION byte b[];...

    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

    句法 :

    < data type > < variable >[];
    < data type >[] < variable >;

    Java字节数组示例

    /*  Java byte Array Example
         Save with file name ByteArray.java  */
       
    public class ByteArray
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION
         byte b[];
         //MEMORY ALLOCATION FOR JAVA BYTE ARRAY
         b = new byte [ 4 ];
         //ASSIGNING ELEMENTS TO JAVA BYTE ARRAY
         b[ 0 ] = 20 ;
         b[ 1 ] = 10 ;
         b[ 2 ] = 30 ;
         b[ 3 ] = 5 ;
         //BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
       }
    }

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

    声明时如何为Java字节数组分配值

    /*  How to assign values to java byte array at the time of declaration Example
         Save with file name ByteArray2.java */
       
    public class ByteArray2
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION AND ASSIGNMENT
         byte b[] = { 20 , 10 , 30 , 5 };
         //JAVA BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
       }
    }

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

    如何使用其他Java字节数组变量声明Java字节数组

    /*  How to declare Java byte array with other Java byte array variables Example
         Save with file name ByteArray3.java */
       
    public class ByteArray3
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION
         byte b[], a; //b IS AN ARRAY a IS NOT AN ARRAY
         //MEMORY ALLOCATION FOR JAVA BYTE ARRAY
         b = new byte [ 4 ];
         //ASSIGNING ELEMENTS TO JAVA BYTE ARRAY
         b[ 0 ] = 20 ;
         b[ 1 ] = 10 ;
         b[ 2 ] = 30 ;
         b[ 3 ] = 5 ;
         a = 100 ;
         //JAVA BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         System.out.println( "a value is : " +a);
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
       }
    }

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

    如何将Java字节数组分配给其他Java字节数组

    /*  How to assign Java byte array to other Java byte array Example
         Save with file name ByteArray4.java */
       
    public class ByteArray4
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION
         byte [] a, b; //a AND b ARE ARRAY VARIABLES
         //MEMORY ALLOCATION FOR JAVA BYTE ARRAY
         b = new byte [ 4 ];
         //ASSIGNING ELEMENTS TO JAVA BYTE ARRAY
         b[ 0 ] = 20 ;
         b[ 1 ] = 10 ;
         b[ 2 ] = 30 ;
         b[ 3 ] = 5 ;
         //ASSIGNING b ARRAY TO a ARRAY VARIABLE
         a = b;
         //JAVA BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         System.out.println( "b array values" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
         System.out.println( "a array values" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + a[i]);
         }
       }
    }
     
     

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

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

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

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

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

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

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

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

    /*  How to convert String to byte array in Java Example
         Save with file name StringToByteArray.java */
      
    import java.util.Arrays;
      
    // Convert String to byte array in Java
    public class StringToByteArray
    {
       public static void main(String[] args)
       {
         String str = " convert String to byte Array in Java " ;
         byte [] bytearray = str.getBytes();
         System.out.println(Arrays.toString(bytearray));
       }
    }

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

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

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

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

    /*  How to convert String to byte array in Java 8 Example
         Save with file name StringToByteArrayJava8.java */
    import java.util.Arrays;
    import java.util.Base64;
      
    // Convert String to byte array in Java 8
    public class StringToByteArrayJava8
    {
       public static void main(String[] args)
       {
         String str = " convert String to byte Array in Java " ;
         byte [] bytearray = Base64.getDecoder().decode(str);
         System.out.println(Arrays.toString(bytearray));
       }
    }
     

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

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

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

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

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

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

    /*  How to convert a byte Array to String in Java
         without character encoding Example
         Save with file name ByteArrayToString.java */
    import java.io.IOException;
    import java.util.Arrays;
      
    // Convert a byte array to String in Java
    public class ByteArrayToString
    {
       public static void main(String[] args) throws IOException
       {
      
         byte [] bytes = " convert a byte Array to String in Java without character encoding " .getBytes();
          System.out.println(Arrays.toString(bytes));
      
         // Create a string from the byte array
         // without specifying character encoding
         String string = new String(bytes);
         System.out.println(string);
       }
    }
     
     

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

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

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

    /*  How to convert a byte Array to String in Java
         with character encoding Example
         Save with file name ByteArrayToString2.java */
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
      
    // Convert a byte array to String in Java
    class ByteArrayToString2
    {
       public static void main(String[] args) throws IOException
       {
         byte [] bytes = " convert a byte Array to String in Java with UTF-8 character encoding " .getBytes(StandardCharsets.UTF_8);
      
         // Create a string from the byte array with "UTF-8" encoding
         String str = new String(bytes, StandardCharsets.UTF_8);
         System.out.println(str);
       }
    }

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

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

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

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

    /*  How to convert byte array to String in Java 8 Example
         Save with file name ByteArrayToStringJava8.java */
    import java.util.Arrays;
    import java.util.Base64;
      
    // Convert byte array String in Java 8
    public class ByteArrayToStringJava8
    {
       public static void main(String[] args)
       {
          
         byte [] bytearray = " convert byte Array to String in Java 8 " .getBytes();
         String str = Base64.getEncoder().encodeToString(bytearray);
         System.out.println(str);
       }
    }
     

    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整数转换为字节数组?

    /*  How to convert Java integer to byte Array Example
         Save with file name IntToByteArray.java */
    import java.nio.ByteBuffer;
      
    // Convert integer to byte array
    public class IntToByteArray
    {
       public static void main(String[] args)
       {
         byte [] bytes = ByteBuffer.allocate( 4 ).putInt( 1695609641 ).array();
      
         for ( byte b : bytes)
         {
           System.out.format( "0x%x " , b);
         }
       }
    }
     
     

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

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

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

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

    /*  How to convert Java byte Array to long Example
         Save with file name ByteArrayToLong.java */
    import java.nio.ByteBuffer;
      
    // Convert byte array to long
    public class ByteArrayToLong
    {
       public static void main(String[] args)
       {
         byte [] bytes = { 0 , 6 , 36 , - 84 , 113 , 125 , - 118 , - 47 };
         System.out.println(ByteBuffer.wrap(bytes).getLong());
         System.out.println(convertByteArrayToLong(bytes));
       }
       public static long convertByteArrayToLong( byte [] longBytes)
       {
         ByteBuffer byteBuffer = ByteBuffer.allocate(Long.BYTES);
         byteBuffer.put(longBytes);
         byteBuffer.flip();
         return byteBuffer.getLong();
       }
    }

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

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

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

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

    /*  How to convert an object to byte array Example
         Save with file name ObjectToByteArray.java */
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    import java.io.IOException;
      
    // Convert an object to byte array
    public class ObjectToByteArray
    {
       public static void main(String[] args)
       {
         Sample yourObject = null ;
         ByteArrayOutputStream bos = null ;
         ObjectOutputStream out = null ;
         try
         {
           yourObject = new Sample();
           bos = new ByteArrayOutputStream();
           out = new ObjectOutputStream(bos);
           out.writeObject(yourObject);
           out.flush();
           byte [] yourBytes = bos.toByteArray();
         }
         catch (Exception e)
         {
           // handle exception here.
         }
         finally
         {
           try
           {
             bos.close();
           } catch (IOException ex)
           {
             // ignore close exception
           }
         }
       }
    }
      
    class Sample implements Serializable
    {
       public void display()
       {
         System.out.println( "This is a sample class" );
       }
    }
     

    如何使用Java将byte [](数组)转换为文件?

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

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

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

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

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

    如何使用Java将byte [](数组)转换为文件?

    /*  How to convert byte array to File Example
         Save with file name ByteArrayToFile.java */
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.OutputStream;
      
    // Convert byte array to File
    public class ByteArrayToFile
    {
       public static void main(String[] args)
       {
         byte [] bytes = "hello" .getBytes();
         File file = new File( "c:\\demo.txt" );
         try
         {
           OutputStream os = new FileOutputStream(file);
           os.write(bytes);
           System.out.println( "Write bytes to file." );
           printContent(file);
           os.close();
         }
         catch (Exception e)
         {
           e.printStackTrace();
         }
       }
       public static void printContent(File file) throws Exception
       {
         System.out.println( "Print File Content" );
         BufferedReader br = new BufferedReader( new FileReader(file));
         String line = null ;
         while ((line = br.readLine()) != null )
         {
           System.out.println(line);
         }
         br.close();
       }
    }

     

     

    展开全文
  • 有一个String ``` String e = "aa"; ...byte[] a = new byte[] { 0x01, (byte) 0xFF, 0x0A, 0x00, (byte) 0xAA, 0x13,}; ``` 现在要把byte f 和byte[] a进行拼接 怎么讲byte f转成byte 数组!
  • Java中的byte详解

    千次阅读 2020-09-29 17:24:23
    Java中的byte详解 介绍 byte,即字节,由8位的二进制组成。在Java中,byte类型的数据是8位带符号的二进制数。 在计算机中,8位带符号二进制数的取值范围是[-128, 127],所以在Java中,byte类型的取值范围也是[-128, ...

    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表示负数

    类型字节数bit位数取值范围
    byte18-128到127
    short216-215到215-1
    int432-231到231-1
    long864-263到263-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) – 低位

    ​ 低地址

    内存地址小端模式存放内容大端模式存放内容
    0x40000x780x12
    0x40010x560x34
    0x40020x340x56
    0x40030x120x78

    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数组互转

    千次阅读 2021-02-24 11:47:03
    c++ 基本类型与byte 数组互相转换 前言 由于根据编译器的不同 有部分基础数据类型字节数不一致 本文档 基础类型位数如下 bool 字节数: 1 char 字节数: 1 short 字节数: 2 int 字节数: 4 long 字节数...

    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);
        }
    
    }
    
    
    展开全文
  • C++17之std::byte

    千次阅读 2019-09-05 22:01:33
    在c++ 17引入了 一种std::byte类型,它确实表示内存元素的“nature”类型字节。与char或int类型的关键区别在于,它不是字符类型且非算术类型。 byte 只是位的汇集,而且只对它定义逐位运算符。即唯一支持的“计算”...
  • 注:getMimeDecoder方法要求密码是4字节对齐(测试过程中1234可以,12345就不行,是因为传输到服务器的字符串中间有空格,还原为+即可),否则会报错:Input byte array has wrong 4-byte ending unit 2、手动对...
  • C#编程,byte 与 int 相互转换

    千次阅读 2022-02-16 15:23:34
    1、byte转int byte[] k = { 225,7,0,0 }; int g = System.BitConverter.ToInt32(k,0); 2、byte转int /** * byte数组中取int数值,本方法适用于(低位在前,高位在后)的顺序,和和intToBytes()配套使用 * * ...
  • 项目过程中用到byte[]数组相加问题,给出两个byte[]需要合并成一个byte[]进行计算…那么需求来了……数据量达10W级,怎么合并 调用系统自带方法(System.arraycopy) 参考程序 @org.junit.Test public void fun...
  • java中打印byte数组

    千次阅读 2021-03-21 09:25:57
    JAVA字节转换 字节(Byte)简称:"B",字位(Bit)简称“b“, 1 个字位(Bit)=1 个二进制数, 1 个字节=8 个字位=8 个二进制数, 1 个汉字=2 两个字节=......“Java is Good!; InputStream input = new ByteArrayInputStream...
  • Cstring 与BYTE类型之间转换

    热门讨论 2012-03-31 17:00:52
    Cstring 与BYTE类型之间转换,实现字节与字符串的转换,将字符串转化为字节类型。0进制与16进制间转换
  • Java中byte与16进制字符串的互相转换

    千次阅读 2021-02-13 02:09:34
    ava中byte用二进制表示占用8位,而我们知道16进制的每个字符需要用4位二进制位来表示(23 + 22 + 21 + 20 = 15),所以我们就可以把每个byte转换成两个相应的16进制字符,即把byte的高4位和低4位分别转换成相应的16...
  • byte数组追加 java

    千次阅读 2021-02-12 21:15:56
    } //java 合并两个byte数组 public static byte[] byteMerger(byte[] byte_1, byte[] byte_2){ byte[] byte_3 = new byte[byte_1.length+byte_2.length]; System.arraycopy(byte_1, 0, byte_3, 0, byte_1.length); ...
  • byte byt[] = new byte[1024]的含义

    千次阅读 2021-11-23 17:33:30
    byte byt[] = new byte[1024]; //1024是什么意思 byte数组的初始化,数组的长度为1024, 从你的代码看来表达的是每次从文件读取1024个字节。 8bit(位)是1byte(字节) 1024byte是1kb byte byt[] = new byte[1024]是1k...
  • golang中[]byte转成string

    千次阅读 2021-10-31 13:53:33
    项目中 RPC 接口由于在入口直接打印 []byte 字节数组形式了,在查询日志的时候很难辨认,需要把其复制下来,再转成字符串。 比如,日志中打印的是 “[104 101 108 108 111 32 119 111 114 108 100]” 这样形式的 ...
  • C# int转byte[],byte[]转int

    千次阅读 2020-12-28 20:53:26
    第一种方法:byte数组转intu = (uint)(b[0] | b[1] << 8 |b[2] << 16 | b[3] << 24);int转byte数组b[0] = (byte)(u);b[1] = (byte)(u >> 8);b[2] = (byte)(u >> 16);b[3] = (byte)(u ...
  • 使用javax.crypto.Cipher库数字签名,输出结果byte[],转化成String类型传输,收到后转化为byte[]类型进行验证数据签名,发现收到的数据长度变了,字符不变。如下图 查了一下
  • Byte[] 转换 截取等操作

    千次阅读 2019-03-21 09:42:44
    包含:16进制字符串转换Byte[]、Byte[]转换成16进制字符、字符串转换成十六进制字符串、16进制直接转换成为字符串(无需Unicode解码)、校验和、Byte[]截取指定长度数组、BCD码转为10进制串(阿拉伯数据)、int与byte 互...
  • 循环遍历byte[]通过System.arraycopy实现 因为我需要封装一段完整的数据流通过netty-websocket发送服务端进行语音识别操作。 websocket中传送的对象是ByteBuf,因为没有现成的方法将ArrayList<byte[]>对象...
  • Bytebyte的区别和联系

    千次阅读 2020-12-10 13:17:19
    1:byteByte区别 byte是java的基本数据类型,存储整型数据,占据1个字节(8 bits),能够存储的数据范围是-128~+127。 Byte是java.lang中的一个类,目的是为基本数据类型byte进行封装。 2:二者联系: Bytebyte...
  • byte怎么转换为char

    千次阅读 2021-02-27 10:18:28
    展开全部byte 是字节62616964757a686964616fe78988e69d8331333337376333数据类型 ,是有符号型的,占1 个字节;大小范围为-128—127 。char 是字符数据类型 ,是无符号型的,占2字节(Unicode码 );大小范围 是0—...
  • Java 字节数组(byte[])和整型(int)的相互转换
  • bytevalue 字节类byteValue()方法 (Byte class byteValue() method) byteValue() method is available in java.lang package. byteValue()方法在java.lang包中可用。 byteValue() method is used to return the ...
  • Java byte[] 和 String互相转换

    千次阅读 2021-04-19 15:11:52
    通过用例学习Java中的byte数组和String互相转换,这种转换可能在很多情况需要,比如IO操作,生成加密hash码等等。 除非觉得必要,否则不要将它们互相转换,他们分别代表了不同的数据,专门服务于不同的目的,通常...
  • java Byte 方法详解

    千次阅读 2019-08-27 11:51:32
    直接来码 ... public class ByteDamo { static void m1() { //byte 的构造函数 Byte bb=new Byte((byte) 333); System.out.println(bb); Byte jByte=new Byte("33"); System.out.println(jByte)...
  • BYTE c++ BYTE相关操作。 字符串转BYTE(“0x14”->0x14) 下面的函数为MFC中获取控件中的输入文字,将其转换为对应的16进制BYTE void GetHexFromStr(CWnd *wd, BYTE *nByte) { CString strText; wd->...
  • byte数组存储到mysql

    千次阅读 2021-03-14 15:56:39
    public int AddVeinMessage(byte[] data)//插入数据库{using (BCSSqlConnection = new MySqlConnection(strConn)){try{dbHelper = new DBHelper(BCSSqlConnection);StringBuilder sbSql = new StringBuilder();sbSql...
  • byte b = (byte)129

    千次阅读 2020-11-08 20:13:34
    有这么一个题,byte b = (byte)129; 我先在控制台打印了一下,发现竟然等于“-127”,我也很惊讶,为啥等于-127 我们来分析一下。我们想想,在java语言中,byte只占一个字节的,它的取值范围为负的128到正的127,...
  • byte数组拼接

    千次阅读 2021-06-17 11:10:03
    /** * 拼接byte数组 ... public static byte[] addBytes(byte[] data1, byte[] data2) { byte[] data3 = new byte[data1.length + data2.length]; System.arraycopy(data1, 0, data3, 0, data1.length)..

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,664,287
精华内容 665,714
关键字:

byte

友情链接: ireport.zip