java整型数与网络字节序的 byte[] 数组转换关系

Java中的基本数据类型和基本数据类型之间的转换在Java中有8中基本数据类型，分别为：整型： byte、short、int、long浮点型：float、double布尔型：boolean字符型：char.byte: 8位，封装类：Byte 1byte = 8bit; -128~127之间所有的整数 "位"是byte,"字节"是bit 2个字节表⽰⼀个字符。

声明举例：byte a = 1;short: 16位，短整型，封装类Short，范围在（-2^15） ~ （2^15）-1 之间 short 2byte = 16bit 声明举例：short a = 1;int : 32位，整型，封装类Integer ，范围在(-2^31) ~ (2^31)-1 之间 int 4byte = 32bit 默认整型直接量为int 声明举例：int a = 1;long: 64位，长整型，封装类Long,范围在(-2^63) ~ (2^63)-1 之间 ling 8byte = 64bit 声明举例：long a = 1L;或者 long a = 1l;float: 单精度浮点型，封装类Float, float 4byte = 4*8bit = 32bit 32位 声明举例：float a = 1.1f;或者float a = 1.1F;double:双精度浮点型，封装类Double double 8byte = 8*8bit = 64bit 64位 默认浮点型直接量为double 声明举例：double a = 1.1;char: 字符类型，封装类Character Java中采⽤unicode编码 char类型占⽤两个字节， java中的字符类型⽤单引号声明 声明举例：char a = 'a'; char a = 97; //ascii中97对应的字符为a char a = '中'； char a = '\u987f';boolean:布尔型，封装类Boolean 只能存储 true ，false------------------------------------------------------------------------------------------------数据类型之间的转换： ⾃动类型转换：byte --> short --> int --> long --> float --> double char-----^ ⼩的类型可以⾃动转换成⼤的类型 例如：double a = 1; //会⾃动转换成1.0 强制类型转换：⼤的类型转换成⼩的类型，会出现精度损失或者溢出 例如：double a = 1.0; float a1 = (float)a;----------------------------------------------------------------------------------------------------- 整型直接量可以直接赋值给byte,short,char,只要不超过其范围就可以byte,short,char参与运算时，会先统⼀转换成int类型，然后再运算 整数之间相除结果还是整数，⼩数舍去 不同数据类型之间运算，会先转换成⼤的数据类型，然后再运算 double计算时会出现舍⼊差，2进制系统中⽆法精确的表⽰1/10，就好像⼗进制中⽆法精确表⽰1/3⼀ 样。

java中int与byte，以及long与byte之间的转换原⽂地址：/zgyulongfei/article/details/7738970public class Utilities {public static byte[] int2Bytes(int num) {byte[] byteNum = new byte[4];for (int ix = 0; ix < 4; ++ix) {int offset = 32 - (ix + 1) * 8;byteNum[ix] = (byte) ((num >> offset) & 0xff);}return byteNum;}public static int bytes2Int(byte[] byteNum) {int num = 0;for (int ix = 0; ix < 4; ++ix) {num <<= 8;num |= (byteNum[ix] & 0xff);}return num;}public static byte int2OneByte(int num) {return (byte) (num & 0x000000ff);}public static int oneByte2Int(byte byteNum) {return byteNum > 0 ? byteNum : (128 + (128 + byteNum));}public static byte[] long2Bytes(long num) {byte[] byteNum = new byte[8];for (int ix = 0; ix < 8; ++ix) {int offset = 64 - (ix + 1) * 8;byteNum[ix] = (byte) ((num >> offset) & 0xff);}return byteNum;}public static long bytes2Long(byte[] byteNum) {long num = 0;for (int ix = 0; ix < 8; ++ix) {num <<= 8;num |= (byteNum[ix] & 0xff);}return num;}public static void main(String[] args) {int num = 129;System.out.println("测试的int值为:" + num);byte[] int2bytes = Utilities.int2Bytes(num);System.out.printf("int转成bytes: ");for (int i = 0; i < 4; ++i) {System.out.print(int2bytes[i] + " ");}System.out.println();int bytes2int = Utilities.bytes2Int(int2bytes);System.out.println("bytes转⾏成int: " + bytes2int);byte int2OneByte = Utilities.int2OneByte(num);System.out.println("int转⾏成one byte: " + int2OneByte);int oneByte2Int = Utilities.oneByte2Int(int2OneByte);System.out.println("one byte转⾏成int: " + oneByte2Int);System.out.println();long longNum = 100000;System.out.println("测试的long值为：" + longNum);byte[] long2Bytes = Utilities.long2Bytes(longNum);System.out.printf("long转⾏成bytes: ");for (int ix = 0; ix < long2Bytes.length; ++ix) {System.out.print(long2Bytes[ix] + " ");}System.out.println();long bytes2Long = Utilities.bytes2Long(long2Bytes); System.out.println("bytes转⾏成long: " + bytes2Long); }}测试的int值为:129int转成bytes: 0 0 0 -127bytes转⾏成int: 129int转⾏成one byte: -127one byte转⾏成int: 129测试的long值为：100000long转⾏成bytes: 0 0 0 0 0 1 -122 -96bytes转⾏成long: 100000。

java中long,int,short与byte数组之间的转换//long类型转成byte数组public static byte[] longToByte(long number) {long temp = number;byte[] b = new byte[8];for (int i = 0; i < b.length; i++) {b[i] = new Long(temp & 0xff).byteValue();// 将最低位保存在最低位temp = temp >> 8; // 向右移8位}return b;}//byte数组转成longpublic static long byteToLong(byte[] b) {long s = 0;long s0 = b[0] & 0xff;// 最低位long s1 = b[1] & 0xff;long s2 = b[2] & 0xff;long s3 = b[3] & 0xff;long s4 = b[4] & 0xff;// 最低位long s5 = b[5] & 0xff;long s6 = b[6] & 0xff;long s7 = b[7] & 0xff;// s0不变s1 <<= 8;s2 <<= 16;s3 <<= 24;s4 <<= 8 * 4;s5 <<= 8 * 5;s6 <<= 8 * 6;s7 <<= 8 * 7;s = s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7;return s;}/*** 注释：int到字节数组的转换！** @param number* @return*/public static byte[] intToByte(int number) {int temp = number;byte[] b = new byte[4];for (int i = 0; i < b.length; i++) {b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位temp = temp >> 8; // 向右移8位}return b;}/*** 注释：字节数组到int的转换！** @param b* @return*/public static int byteToInt(byte[] b) {int s = 0;int s0 = b[0] & 0xff;// 最低位int s1 = b[1] & 0xff;int s2 = b[2] & 0xff;int s3 = b[3] & 0xff;s3 <<= 24;s2 <<= 16;s1 <<= 8;s = s0 | s1 | s2 | s3;return s;}/*** 注释：short到字节数组的转换！** @param s* @return*/public static byte[] shortToByte(short number) {int temp = number;byte[] b = new byte[2];for (int i = 0; i < b.length; i++) {b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位temp = temp >> 8; // 向右移8位}return b;}/*** 注释：字节数组到short的转换！** @param b* @return*/public static short byteToShort(byte[] b) { short s = 0;short s0 = (short) (b[0] & 0xff);// 最低位 short s1 = (short) (b[1] & 0xff); s1 <<= 8;s = (short) (s0 | s1);return s;}。

java 基本类型转byte 原理摘要：1.Java基本数据类型概述2.byte类型与其它基本数据类型的关系3.Java中byte转float的原理4.实际应用场景及注意事项正文：Java基本数据类型分为字节型（byte）、短整型（short）、整型（int）、长整型（long）、单精度浮点型（float）、双精度浮点型（double）、布尔型（boolean）和字符型（char）。

在这些类型之间，可以进行相互转换。

本文将重点介绍byte类型与其他类型之间的转换，特别是byte转float的原理及其应用场景。

首先，让我们了解一下byte类型。

在Java中，byte类型是8位的，即1个字节。

它的默认值为0，取值范围为-128至127。

与其他类型相比，byte 类型的数值范围较小，但在某些场景下，如处理IO、网络传输等，byte类型具有优势。

接下来，我们探讨一下byte类型与其他类型的关系。

在Java中，不同数据类型之间可以进行转换，但需要注意以下几点：1.整型转换：byte类型可以转换为int、long类型，但反之则需要进行强制转换。

2.浮点型转换：byte类型可以转换为float、double类型，但反之则需要进行强制转换。

3.布尔型转换：byte类型可以转换为boolean类型，但反之则需要进行强制转换。

4.字符型转换：byte类型可以转换为char类型，但反之则需要进行强制转换。

在上述转换中，byte转float的原理尤为重要。

在Java中，byte转float 的过程实质上是将byte数值转换为float数值。

具体来说，首先将byte数值转换为int类型，然后将int类型转换为float类型。

以下是一个示例：```javabyte b = 10;float f = (float) (b & 0xFF);```在上面的代码中，我们首先将byte类型的变量b转换为int类型，然后将int类型转换为float类型。

java中byte，byte[]和int之间的转换1>byte类型转换为，直接隐式转换,适⽤于要求保持数值不变，例如要求进⾏数值计算如 byte b=0x01; int i=b;2>另⼀种是要求保持最低字节中各个位不变，3个⾼字节全部⽤0填充，例如进⾏编解码操作，则需要采⽤位操作，int i=b & 0xff;3>byte[]数组和int之间的转换// 将byte[]转换为int类型public static int byte2int(byte[] res) {// ⼀个byte数据左移24位变成0x??000000，再右移8位变成0x00??0000int targets = (res[0] & 0xff) | ((res[1] << 8) & 0xff00) // | 表⽰安位或| ((res[2] << 24) >>> 8) | (res[3] << 24);return targets;}// 将int类型装换为byte[]数组public static byte[] int2byte(int res) {byte[] targets = new byte[4];targets[0] = (byte) (res & 0xff);// 最低位targets[1] = (byte) ((res >> 8) & 0xff);// 次低位targets[2] = (byte) ((res >> 16) & 0xff);// 次⾼位targets[3] = (byte) (res >>> 24);// 最⾼位,⽆符号右移。

return targets;}。

java中int与byte相互转换1：int和byte的关系 在java中，int整形变量是32位的，⽽byte是8位的，他们之间的转换有⼀定的策略和讲究。

1.1：int 到byte⾸先我们实现int和byte之间的转换，思路如下：1. 创建⼀个byte数组，长度为4。

byte[0]是最⾼位，byte[1]是次⾼位，byte[2]是次次⾼位，byte[3]是最低位，2. 在将int数据右移24位，然后与0xFF相与即可得到byte[0]。

3. 在将int数据右移16位，然后与0xFF相与即可得到byte[1]。

4. 在将int数据右移8位，然后与0xFF相与即可得到byte[2]。

5. 在将int数据右移0位，然后与0xFF相与即可得到byte[3]。

6. 输出byte[]数组即可。

1.2：byte 到int⾸先我们实现byte和int之间的转换，思路如下：1. 输⼊⼀个byte数组，长度为4。

byte[0]是最⾼位，byte[1]是次⾼位，byte[2]是次次⾼位，byte[3]是最低位，2. 创建⼀个int型变量sum，作为byte到int的结果。

3. ⽤⼀个for(int i=0;i<4;i++)的循环。

每次将(3-i)*8的值，作为该byte的权重。

4. sum = sum + byte[i]<<(3-i)*8。

重复3-4即可。

5. return sum即可。

2：代码实现/*** 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;}。

byte数组与byte数组转化byte数组与byte数组之间的转化是在编程中经常遇到的需求。

有时候，我们需要将一个byte数组转化为另一个byte数组来满足我们的需要。

这些需要包括但不限于：网络传输数据、数据加密、数据压缩等等。

在本文中，我将讨论如何在Java中将byte数组转化为另一个byte数组。

在Java中，byte数组是存储二进制数据的一种数据类型。

它由固定长度的字节组成，每个字节都保存了一个8位的二进制值。

因此，byte数组可以表示任何二进制数据，如图像、音频、视频等。

要将一个byte数组转化为另一个byte数组，我们可以使用Java提供的一些方法和技巧。

下面是一些可供参考的方法和思路：1. 使用System.arraycopy()方法：这是Java中最常用的将一个byte数组复制到另一个byte数组的方法之一。

该方法可以在两个数组之间执行快速的内存复制，以达到将一个数组复制到另一个数组的目的。

以下是使用System.arraycopy()方法的示例代码：```javabyte[] sourceArray = {1, 2, 3, 4, 5};byte[] destinationArray = new byte[sourceArray.length];System.arraycopy(sourceArray, 0, destinationArray, 0,sourceArray.length);```在上面的代码中，我们首先创建了一个源数组sourceArray 和一个目标数组destinationArray。

然后，我们使用System.arraycopy()方法将源数组的内容复制到目标数组中。

2. 使用ByteArrayOutputStream和ByteArrayInputStream：Java中的ByteArrayOutputStream和ByteArrayInputStream类提供了用于在内存中生成和处理字节数组的功能。

Java中字符串与byte数组之间的相互转换前⾔Java与其他语⾔编写的程序进⾏tcp/ip socket通讯时，通讯内容⼀般都转换成byte数组型，java在字符与数组转换也是⾮常⽅便的。

下⾯跟我⼀起来了解⼀下字符串与byte之间转换的原理原理我们都知道，在Java⾥byte类型是占⽤1个字节，即8位的，⽽16进制的字符占⽤4位，所以每个byte可以⽤两个字符来表⽰，反之亦然。

举个例⼦byte = 123⽤⼆进制表⽰：0111 1011每4位⽤字符表⽰：7 b是的，原理就这么简单，接下来⽤代码实现：byte[] 转16进制字符串⽅法⼀思路：先把byte[] 转换维char[]，再把char[]转换为字符串public static String bytes2Hex(byte[] src) {if (src == null || src.length <= 0) {return null;}char[] res = new char[src.length * 2]; // 每个byte对应两个字符final char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };for (int i = 0, j = 0; i < src.length; i++) {res[j++] = hexDigits[src[i] >> 4 & 0x0f]; // 先存byte的⾼4位res[j++] = hexDigits[src[i] & 0x0f]; // 再存byte的低4位}return new String(res);}⽅法⼆思路：先把byte转换为int类型，再转换为字符串public static String bytesToHex(byte[] src){if (src == null || src.length <= 0) {return null;}StringBuilder stringBuilder = new StringBuilder("");for (int i = 0; i < src.length; i++) {// 之所以⽤byte和0xff相与，是因为int是32位，与0xff相与后就舍弃前⾯的24位，只保留后8位String str = Integer.toHexString(src[i] & 0xff);if (str.length() < 2) { // 不⾜两位要补0stringBuilder.append(0);}stringBuilder.append(str);}return stringBuilder.toString();}16进制字符串转byte[]思路：先把字符串转换为char[] ，再转换为byte[]public static byte[] hexToBytes(String hexString) {if (hexString == null || hexString.equals("")) {return null;}int length = hexString.length() / 2;char[] hexChars = hexString.toCharArray();byte[] bytes = new byte[length];String hexDigits = "0123456789abcdef";for (int i = 0; i < length; i++) {int pos = i * 2; // 两个字符对应⼀个byteint h = hexDigits.indexOf(hexChars[pos]) << 4; // 注1int l = hexDigits.indexOf(hexChars[pos + 1]); // 注2if(h == -1 || l == -1) { // ⾮16进制字符return null;}bytes[i] = (byte) (h | l);}return bytes;}注：注1得到xxxx0000，注2得到0000xxxx，相或就把两个字符转换为⼀个byte了。

JAVA中基本数组类型转byte数组在⽇常的项⽬中，我们经常会遇到这样的问题，就是将基本数据类型转化成字节数据，其实，字节数组是我们经常使⽤的，包括⽂件流，以及socket的数据传输，基本都是要求字节数组，虽然⼤部分⼈可能都使⽤应⽤层协议http，⼀般都会使⽤json作为传输格式，但其实底层传输层还是将这些数据进⾏了序列化，因此我们应该熟悉这种基本数据类型和字节数组的转化。

当然这种应⽤场景也是⾮常的多，⽐如很多时候我们都希望⽂件的关键信息存储成字节数组，这样对外不容易解析，虽然存储成⼆进制也没有问题，但是直接存储成⼆进制，在解析上会有⼀些⿇烦，⽽存储成字节数据，我们很清楚每4个字节组成⼀个int，这样处理起来相对⽅便⼀点，不需要认为约定很多东西下⾯就是int和byte[]的转换⽅式，public class NumConvert {public static void main(String[] args) {System.out.println(Integer.toBinaryString(257));System.out.println(bytes2Int(int2Bytes(257)));}/*** 转化过程⼀定是⾼位在前* @param num* @return*/public static byte[] int2Bytes(int num) {byte[] result = new byte[4];result[0] = (byte)((num >>> 24) & 0xff);result[1] = (byte)((num >>> 16) & 0xff );result[2] = (byte)((num >>> 8) & 0xff );result[3] = (byte)((num >>> 0) & 0xff );return result;}public static int bytes2Int(byte[] bytes ) {int int1 = (bytes[0]&0xff) << 24;int int2 = (bytes[1]&0xff) << 16;int int3 = (bytes[2]&0xff) << 8;int int4 = (bytes[3]&0xff);return int1|int2|int3|int4;}}。

字节数组byte[]和整型,浮点型数据的转换——Java代码近期在写C++ socket和java socket之间的通信程序，涉及到整数浮点数的传输。

须要从字节数组还原数据，查了⼀些资料。

总结例如以下1. 整数和浮点数的机器表⽰在机器内部。

不论是⼀个整数还是浮点数。

都是以⼀个⼆进制串的形式存储。

整数可能是原码。

补码表⽰，浮点数有阶码尾数两部分构成。

不管如何都是⼀个⼆进制串。

可是这个⼆进制串如何表⽰不同的机器可能採取不同的⽅案。

关于浮点数：⼀个机器上的32位浮点数的⼆进制串在还有⼀个机器把它作为32位浮点数解释时可能得到不同的值，这样不同机器上进⾏⽹络传输的时候，⼤概就仅仅能⽤传字符串的⽅式了。

只是幸好。

IEEE 754规范标准化了浮点数的表⽰形式。

遵从这个标准的不同编程语⾔⾥仅仅要遵从这个标准，那么某个浮点数的32位⼆进制串都是⼀样的，，，和CPU⽆关，和语⾔⽆关关于整数：单个字节的整型值就是⼀个字节；占⽤多个字节的整数，其表⽰有所差别，有所谓的⼩端法。

⼤端法,详细表⽰能够看以下的图。

2. ⼩端法、⼤端法和主机字节顺序、⽹络字节顺序⼩端法和⼤端法如图所看到的⽹络字节序就是⼤端顺序，由于TCP/IP⾸部中全部的⼆进制整数在⽹络中传输时都要求以这样的次序，因此它⼜称作⽹络字节序。

主机字节顺序就是指相对于⽹络传输是的字节顺序的主机上的字节顺序。

有⼤端表⽰法，⼩端表⽰法。

3. 以下给出java中的基本数据类型和字节数组byte[]之间的转换代码本⽂中byte[]的顺序依照“⼤端顺序”。

这句话的意思是说对于整数0x11223344byte[0]保存0x11。

byte[1]保存0x22。

byte[2]保存0x33，byte[3]保存0x44採⽤这样的“⼤端顺序”，由byte[]转int，或由int转byte[]。

这⾥⾯byte的顺序都须要是上⾯描写叙述的“⼤端顺序”，这样优点是server发送时能够调⽤htonl。

java整数和byte数组之间的转换做的程序有时候会需要⽤到,记录下[java]view plaincopy1. public class NumberUtil {2. /**3. * int整数转换为4字节的byte数组4. *5. * @param i6. * 整数7. * @return byte数组8. */9. public static byte[] intToByte4(int i) {10. byte[] targets = new byte[4];11. targets[3] = (byte) (i & 0xFF);12. targets[2] = (byte) (i >> 8 & 0xFF);13. targets[1] = (byte) (i >> 16 & 0xFF);14. targets[0] = (byte) (i >> 24 & 0xFF);15. return targets;16. }17.18. /**19. * long整数转换为8字节的byte数组20. *21. * @param lo22. * long整数23. * @return byte数组24. */25. public static byte[] longToByte8(long lo) {26. byte[] targets = new byte[8];27. for (int i = 0; i < 8; i++) {28. int offset = (targets.length - 1 - i) * 8;29. targets[i] = (byte) ((lo >>> offset) & 0xFF);30. }31. return targets;32. }33.34. /**35. * short整数转换为2字节的byte数组36. *37. * @param s38. * short整数39. * @return byte数组40. */41. public static byte[] unsignedShortToByte2(int s) {42. byte[] targets = new byte[2];43. targets[0] = (byte) (s >> 8 & 0xFF);44. targets[1] = (byte) (s & 0xFF);45. return targets;46. }47.48. /**49. * byte数组转换为⽆符号short整数50. *51. * @param bytes52. * byte数组53. * @return short整数54. */55. public static int byte2ToUnsignedShort(byte[] bytes) {56. return byte2ToUnsignedShort(bytes, 0);57. }58.59. /**60. * byte数组转换为⽆符号short整数61. *62. * @param bytes63. * byte数组64. * @param off65. * 开始位置66. * @return short整数67. */68. public static int byte2ToUnsignedShort(byte[] bytes, int off) {69. int high = bytes[off];70. int low = bytes[off + 1];71. return (high << 8 & 0xFF00) | (low & 0xFF);72. }73.74. /**75. * byte数组转换为int整数76. *77. * @param bytes78. * byte数组79. * @param off80. * 开始位置81. * @return int整数82. */83. public static int byte4ToInt(byte[] bytes, int off) {84. int b0 = bytes[off] & 0xFF;85. int b1 = bytes[off + 1] & 0xFF;86. int b2 = bytes[off + 2] & 0xFF;87. int b3 = bytes[off + 3] & 0xFF;88. return (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;89. }90. }。

byte数组与byte数组转化【实用版】目录1.Byte 数组的定义与初始化2.Byte 数组与整数数组之间的关系3.Byte 数组的转换方法4.Byte 数组与字符数组的转换5.实例：Byte 数组与 byte 数组的转化正文一、Byte 数组的定义与初始化Byte 数组是 Java 中一种数据类型，用于存储字节序列。

它可以用来存储图像、声音等各种二进制数据。

在 Java 中，我们可以通过以下方式定义一个 Byte 数组：```javabyte[] byteArray;```初始化 Byte 数组有以下几种方式：1.直接赋值：```javabyte[] byteArray = new byte[5]; // 创建一个长度为 5 的 Byte 数组byteArray[0] = 1;byteArray[1] = 2;byteArray[2] = 3;byteArray[3] = 4;byteArray[4] = 5;```2.使用字面量初始化：```javabyte[] byteArray = {1, 2, 3, 4, 5};```3.使用另一个 Byte 数组进行初始化：```javabyte[] byteArray1 = new byte[5];byte[] byteArray2 = {1, 2, 3, 4, 5};byteArray1 = byteArray2;```二、Byte 数组与整数数组之间的关系在 Java 中，Byte 数组和整数数组之间有一定的关系。

我们可以将Byte 数组看作是整数数组的一个特例，因为 Byte 类型的范围是 -128 到 127，这些值可以被整数数组存储。

同时，整数数组也可以看作是 Byte 数组的一个特例，因为整数数组可以存储所有整数值，而 Byte 数组只能存储 -128 到 127 之间的值。

Java基本类型与byte数组之间相互转换⽅法Java基本类型与byte数组之间相互转换，刚刚写的package cn.teaey.utils;import java.nio.charset.Charset;public class ByteUtil{public static byte[] getBytes(short data){byte[] bytes = new byte[2];bytes[0] = (byte) (data & 0xff);bytes[1] = (byte) ((data & 0xff00) >> 8);return bytes;}public static byte[] getBytes(char data){byte[] bytes = new byte[2];bytes[0] = (byte) (data);bytes[1] = (byte) (data >> 8);return bytes;}public static byte[] getBytes(int data){byte[] bytes = new byte[4];bytes[0] = (byte) (data & 0xff);bytes[1] = (byte) ((data & 0xff00) >> 8);bytes[2] = (byte) ((data & 0xff0000) >> 16);bytes[3] = (byte) ((data & 0xff000000) >> 24);return bytes;}public static byte[] getBytes(long data){byte[] bytes = new byte[8];bytes[0] = (byte) (data & 0xff);bytes[1] = (byte) ((data >> 8) & 0xff);bytes[2] = (byte) ((data >> 16) & 0xff);bytes[3] = (byte) ((data >> 24) & 0xff);bytes[4] = (byte) ((data >> 32) & 0xff);bytes[5] = (byte) ((data >> 40) & 0xff);bytes[6] = (byte) ((data >> 48) & 0xff);bytes[7] = (byte) ((data >> 56) & 0xff);return bytes;}public static byte[] getBytes(float data){int intBits = Float.floatToIntBits(data);return getBytes(intBits);}public static byte[] getBytes(double data){long intBits = Double.doubleToLongBits(data);return getBytes(intBits);}public static byte[] getBytes(String data, String charsetName){Charset charset = Charset.forName(charsetName);return data.getBytes(charset);}public static byte[] getBytes(String data){return getBytes(data, "GBK");}public static short getShort(byte[] bytes){return (short) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));}public static char getChar(byte[] bytes){return (char) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));}public static int getInt(byte[] bytes){return (0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)) | (0xff0000 & (bytes[2] << 16)) | (0xff000000 & (bytes[3] << 24));}public static long getLong(byte[] bytes){return(0xffL & (long)bytes[0]) | (0xff00L & ((long)bytes[1] << 8)) | (0xff0000L & ((long)bytes[2] << 16)) | (0xff000000L & ((long)bytes[3] << 24))| (0xff00000000L & ((long)bytes[4] << 32)) | (0xff0000000000L & ((long)bytes[5] << 40)) | (0xff000000000000L & ((long)bytes[6] << 48)) | (0xff00000000000000L & ((long)bytes[7] << 56)); }public static float getFloat(byte[] bytes){return Float.intBitsToFloat(getInt(bytes));}public static double getDouble(byte[] bytes){long l = getLong(bytes);System.out.println(l);return Double.longBitsToDouble(l);}public static String getString(byte[] bytes, String charsetName){return new String(bytes, Charset.forName(charsetName));}public static String getString(byte[] bytes){return getString(bytes, "GBK");}public static void main(String[] args){short s = 122;int i = 122;long l = 1222222;char c = 'a';float f = 122.22f;double d = 122.22;String string = "我是好孩⼦";System.out.println(s);System.out.println(i);System.out.println(l);System.out.println(c);System.out.println(f);System.out.println(d);System.out.println(string);System.out.println("**************");System.out.println(getShort(getBytes(s)));System.out.println(getInt(getBytes(i)));System.out.println(getLong(getBytes(l)));System.out.println(getChar(getBytes(c)));System.out.println(getFloat(getBytes(f)));System.out.println(getDouble(getBytes(d)));System.out.println(getString(getBytes(string)));}}以上这篇Java基本类型与byte数组之间相互转换⽅法就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

java网络字节序转换关系工程项目开发时常常需要在java和c/c++之间进行socket通信，socket通信是以字节流或者字节包进行的，socket发送方须将数据转换为字节流或者字节包，而接收方则将字节流和字节包再转换回相应的数据类型。

如果发送方和接收方都是同种语言，则一般只涉及到字节序的调整。

而对于java和c/c++的通信，则情况就要复杂一些，主要是因为java中没有unsigned类型，并且java和c在某些数据类型上的长度不一致。

本文就是针对这种情况，整理了java数据类型和网络字节流或字节包(相当于java的byte 数组)之间转换方法。

实际上网上这方面的资料不少，但往往不全，甚至有些有错误，于是就花了点时间对java整型数和网络字节序的byte[]之间转换的各种情况做了一些验证和整理。

整理出来的函数如下：public class ByteConvert {// 以下是整型数和网络字节序的byte[] 数组之间的转换public static byte[] longToBytes(long n) {byte[] b = new byte[8];b[7] = (byte) (n & 0xff);b[6] = (byte) (n >> 8 & 0xff);b[5] = (byte) (n >> 16 & 0xff);b[4] = (byte) (n >> 24 & 0xff);b[3] = (byte) (n >> 32 & 0xff);b[2] = (byte) (n >> 40 & 0xff);b[1] = (byte) (n >> 48 & 0xff);b[0] = (byte) (n >> 56 & 0xff);return b;}public static void longT oBytes( long n, byte[] array, int offset ){array[7+offset] = (byte) (n & 0xff);array[6+offset] = (byte) (n >> 8 & 0xff);array[5+offset] = (byte) (n >> 16 & 0xff);array[4+offset] = (byte) (n >> 24 & 0xff);array[3+offset] = (byte) (n >> 32 & 0xff);array[2+offset] = (byte) (n >> 40 & 0xff);array[1+offset] = (byte) (n >> 48 & 0xff);array[0+offset] = (byte) (n >> 56 & 0xff);}public static long bytesToLong( byte[] array ){return ((((long) array[ 0] & 0xff) << 56)| (((long) array[ 1] & 0xff) << 48)| (((long) array[ 2] & 0xff) << 40)| (((long) array[ 3] & 0xff) << 32)| (((long) array[ 4] & 0xff) << 24)| (((long) array[ 5] & 0xff) << 16)| (((long) array[ 6] & 0xff) << 8)| (((long) array[ 7] & 0xff) << 0));}public static long bytesToLong( byte[] array, int offset ) {return ((((long) array[offset + 0] & 0xff) << 56)| (((long) array[offset + 1] & 0xff) << 48)| (((long) array[offset + 2] & 0xff) << 40)| (((long) array[offset + 3] & 0xff) << 32)| (((long) array[offset + 4] & 0xff) << 24)| (((long) array[offset + 5] & 0xff) << 16)| (((long) array[offset + 6] & 0xff) << 8)| (((long) array[offset + 7] & 0xff) << 0));}public static byte[] intToBytes(int n) {byte[] b = new byte[4];b[3] = (byte) (n & 0xff);b[2] = (byte) (n >> 8 & 0xff);b[1] = (byte) (n >> 16 & 0xff);b[0] = (byte) (n >> 24 & 0xff);return b;}public static void intToBytes( int n, byte[] array, int offset ){ array[3+offset] = (byte) (n & 0xff);array[2+offset] = (byte) (n >> 8 & 0xff);array[1+offset] = (byte) (n >> 16 & 0xff);array[offset] = (byte) (n >> 24 & 0xff);}public static int bytesToInt(byte b[]) {return b[3] & 0xff| (b[2] & 0xff) << 8| (b[1] & 0xff) << 16| (b[0] & 0xff) << 24;}public static int bytesToInt(byte b[], int offset) {return b[offset+3] & 0xff| (b[offset+2] & 0xff) << 8| (b[offset+1] & 0xff) << 16| (b[offset] & 0xff) << 24;}public static byte[] uintT oBytes( long n ){byte[] b = new byte[4];b[3] = (byte) (n & 0xff);b[2] = (byte) (n >> 8 & 0xff);b[1] = (byte) (n >> 16 & 0xff);b[0] = (byte) (n >> 24 & 0xff);return b;}public static void uintT oBytes( long n, byte[] array, int offset ){ array[3+offset] = (byte) (n );array[2+offset] = (byte) (n >> 8 & 0xff);array[1+offset] = (byte) (n >> 16 & 0xff);array[offset] = (byte) (n >> 24 & 0xff);}public static long bytesToUint(byte[] array) {return ((long) (array[3] & 0xff))| ((long) (array[2] & 0xff)) << 8| ((long) (array[1] & 0xff)) << 16| ((long) (array[0] & 0xff)) << 24;}public static long bytesToUint(byte[] array, int offset) { return ((long) (array[offset+3] & 0xff))| ((long) (array[offset+2] & 0xff)) << 8| ((long) (array[offset+1] & 0xff)) << 16| ((long) (array[offset] & 0xff)) << 24;}public static byte[] shortToBytes(short n) {byte[] b = new byte[2];b[1] = (byte) ( n & 0xff);b[0] = (byte) ((n >> 8) & 0xff);return b;}public static void shortT oBytes(short n, byte[] array, int offset ) { array[offset+1] = (byte) ( n & 0xff);array[offset] = (byte) ((n >> 8) & 0xff);}public static short bytesToShort(byte[] b){return (short)( b[1] & 0xff|(b[0] & 0xff) << 8 );}public static short bytesToShort(byte[] b, int offset){return (short)( b[offset+1] & 0xff|(b[offset] & 0xff) << 8 );}public static byte[] ushortToBytes(int n) {byte[] b = new byte[2];b[1] = (byte) ( n & 0xff);b[0] = (byte) ((n >> 8) & 0xff);return b;}public static void ushortToBytes(int n, byte[] array, int offset ) { array[offset+1] = (byte) ( n & 0xff);array[offset] = (byte) ((n >> 8) & 0xff);}public static int bytesToUshort(byte b[]) {return b[1] & 0xff| (b[0] & 0xff) << 8;}public static int bytesToUshort(byte b[], int offset) {return b[offset+1] & 0xff| (b[offset] & 0xff) << 8;}public static byte[] ubyteToBytes( int n ){byte[] b = new byte[1];b[0] = (byte) (n & 0xff);return b;}public static void ubyteToBytes( int n, byte[] array, int offset ){array[0] = (byte) (n & 0xff);}public static int bytesToUbyte( byte[] array ){return array[0] & 0xff;}public static int bytesToUbyte( byte[] array, int offset ){return array[offset] & 0xff;}// char 类型、float、double 类型和byte[] 数组之间的转换关系还需继续研究实现。

java中整形变量与字节数组的转换
⼀直搞不清楚整形变量与字节数组的转换，看过各位⽹友的解释，现写下此随笔：
整形变量转换成字节数组
对于int类型变量a,将其转换为字节数组b，⽅法如下：
int a = 100;
byte[] b = byte[4];
b[3] = (byte)(a & 0xff);
b[2] = (byte)(a>>8 & 0xff);
b[1] = (byte)(a>>16 & 0xff);
b[0] = (byte)(a>>24 & 0xff);
字节数组转换成整形变量
将刚才得到的字节数组b转换成整形变量a，
int a = 0;
for(int i =0; i< b.length; i++){
a += (b[i]&0xff) << (24-8*i);
}
return a;
java⾥对于byte变量，假如操作中有int操作数，默认会将byte隐式转换为int变量，⽽转换成的int变量⾼24位全部为1,在将byte数组转换为int变量的时候，假如直接⽤移位操作就会有⿇烦，因为⾼位都是ffffff，所以需将隐式转换⽣成的ffffff消掉。

因此，将每个字节和0xff相与，然后再移位，最后把各步产⽣的结果相加即可得到原始的int变量。

public class ConvToByte {/*** short类型转换成byte数组** @param param* 待转的short* @return** @author li* @date 2014-1-16 上午10:03:47*/public static byte[] shortToByteArr(short param) { byte[] arr = new byte[2];arr[0] = (byte) ((param >> 8) & 0xff);arr[1] = (byte) (param & 0xff);return arr;}/*** int类型转换成byte数组** @param param* 待转的int* @return** @author li* @date 2014-1-16 上午10:03:47*/public static byte[] intToByteArr(int param) {byte[] arr = new byte[4];arr[0] = (byte) ((param >> 24) & 0xff);arr[1] = (byte) ((param >> 16) & 0xff);arr[2] = (byte) ((param >> 8) & 0xff);arr[3] = (byte) (param & 0xff);return arr;}/*** long类型转换成byte数组** @param param* 待转的long* @return** @author li* @date 2014-1-16 上午10:03:47*/public static byte[] longToByteArr(long param) { byte[] arr = new byte[8];arr[0] = (byte) ((param >> 56) & 0xff);arr[1] = (byte) ((param >> 48) & 0xff);arr[2] = (byte) ((param >> 40) & 0xff);arr[3] = (byte) ((param >> 32) & 0xff);arr[4] = (byte) ((param >> 24) & 0xff);arr[5] = (byte) ((param >> 16) & 0xff);arr[6] = (byte) ((param >> 8) & 0xff);arr[7] = (byte) (param & 0xff);return arr;}/*** 字符到字节转换** @param ch* 字符* @return** @author li* @date 2014-1-16 下午4:10:07*/public static byte[] charToByteArr(char ch) { byte[] b = new byte[2];int temp = (int) ch;b[0] = (byte) (temp >> 8 & 0xff);b[1] = (byte) (temp & 0xff);return b;}/*** double转换byte数组** @param param* double* @return byte数组** @author li* @date 2014-1-16 下午4:45:57*/public static byte[] doubleToByteArr(double param) { byte[] b = new byte[8];long l = Double.doubleToLongBits(param);for (int i = 0; i < b.length; i++) {b[i] = new Long(l).byteValue();l = l >> 8;}return b;}/*** float转换byte数组** @param param* float* @return byte数组** @author li* @date 2014-1-16 下午5:05:04*/public static byte[] floatToByteArr(float param) { byte[] b = new byte[4];int l = Float.floatToIntBits(param);for (int i = 0; i < b.length; i++) {b[i] = new Integer(l).byteValue();l = l >> 8;}return b;}/*** 将2字节的byte数组转成short值** @param b* byte数组* @return** @author li* @date 2014-1-16 下午3:00:01*/public static short byteArrToShort(byte[] b) { byte[] a = new byte[2];int i = a.length - 1, j = b.length - 1;for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据if (j >= 0)a[i] = b[j];else// 如果b.length不足2,则将高位补0a[i] = 0;}// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位int v0 = (a[0] & 0xff) << 8;int v1 = (a[1] & 0xff);return (short) (v0 + v1);}/*** 将4字节的byte数组转成int值** @param b* byte数组* @return** @author li* @date 2014-1-16 下午3:00:01*/public static int byteArrToInt(byte[] b) {byte[] a = new byte[4];int i = a.length - 1, j = b.length - 1;for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据if (j >= 0)a[i] = b[j];else// 如果b.length不足4,则将高位补0a[i] = 0;}// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位int v0 = (a[0] & 0xff) << 24;int v1 = (a[1] & 0xff) << 16;int v2 = (a[2] & 0xff) << 8;int v3 = (a[3] & 0xff);return v0 + v1 + v2 + v3;}/*** 将8字节的byte数组转成long值** @param b* byte数组* @return** @author li* @date 2014-1-16 下午3:00:01*/public static long byteArrToLong(byte[] b) {byte[] a = new byte[8];int i = a.length - 1, j = b.length - 1;for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据if (j >= 0)a[i] = b[j];else// 如果b.length不足4,则将高位补0a[i] = 0;}// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位int v0 = (a[0] & 0xff) << 56;int v1 = (a[1] & 0xff) << 48;int v2 = (a[2] & 0xff) << 40;int v3 = (a[3] & 0xff) << 32;int v4 = (a[4] & 0xff) << 24;int v5 = (a[5] & 0xff) << 16;int v6 = (a[6] & 0xff) << 8;int v7 = (a[7] & 0xff);return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7;}/*** 将2字节的byte数组转成字符值** @param b* byte数组* @return** @author li* @date 2014-1-16 下午3:00:01*/public static char byteArrToChar(byte[] b) {byte[] a = new byte[2];int i = a.length - 1, j = b.length - 1;for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据if (j >= 0)a[i] = b[j];else// 如果b.length不足2,则将高位补0a[i] = 0;}// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位int v0 = (a[0] & 0xff) << 8;int v1 = (a[1] & 0xff);return (char) (v0 + v1);}/*** byte数组到double转换** @param byte数组* @return double** @author li* @date 2014-1-16 下午5:25:14*/public static double byteArrToDouble(byte[] b) {long l;l = b[0];l &= 0xff;l |= ((long) b[1] << 8);l &= 0xffff;l |= ((long) b[2] << 16);l &= 0xffffff;l |= ((long) b[3] << 24);l &= 0xffffffffl;l |= ((long) b[4] << 32);l &= 0xffffffffffl;l |= ((long) b[5] << 40);l &= 0xffffffffffffl;l |= ((long) b[6] << 48);l &= 0xffffffffffffffl;l |= ((long) b[7] << 56);return Double.longBitsToDouble(l);}/*** byte数组到float转换** @param byte数组* @return float** @author li* @date 2014-1-16 下午5:25:14*/public static float byteArrToFloat(byte[] b) { int l;l = b[0];l &= 0xff;l |= ((long) b[1] << 8);l &= 0xffff;l |= ((long) b[2] << 16);l &= 0xffffff;l |= ((long) b[3] << 24);return Float.intBitsToFloat(l);}}。

⼤数据Java基础（⼀）int型与byte型数组的转换int型与byte型数组的转换 为了在接下来的篇章中讲解⽤Java实现⽂件的归档和解归档，需要先了解⼀下Java中int型与byte型数组之间的相互转换。

⾸先，我们先来看看int型转换成byte型数组。

我们知道，Java中，⼀个int型占⽤4个字节，⼀个byte型占⽤1个字节，所以，对于⼀个int型，我们需要⼀个长度为4的byte型数组来对其进⾏存储。

31位——24位23位——16位15位——8位7位——0位 ⼀个int型的4个字节如上图所⽰，假设⽤来存储的字节数组为bytes[]，那么，我们可以⽤bytes[0]存储int型的第⼀个字节（7位——0位），bytes[1]存储int型的第⼆个字节（15位——8位），bytes[2]存储int型的第三个字节（23位——16位），bytes[3]存储int型的第四个字节（31位——24位)。

具体代码如下：1public static byte[] int2Bytes(int integer)2 {3byte[] bytes=new byte[4];4 bytes[3]=(byte) integer>>24;5 bytes[2]=(byte) integer>>16;6 bytes[1]=(byte) integer>>8;7 bytes[0]=(byte) integer;89return bytes;10 } 这⾥需要注意的是，当你将⼀个int型强制类型转换为byte型的时候，最⾼的三个字节会被砍掉，只留下最低的8位赋值给byte型。

接下来，我们来看⼀下byte型数组转换成int型。

我们知道，计算机是以补码的形式存放数值型数据，当我们对⼀个byte型进⾏移位操作的时候，这个byte型会先⾃动补全到32位（即⼀个int型），再进⾏移位操作。

举个例⼦：⼀个byte型的-1，在内存中的补码是⼋个1：11111111，当我们进⾏移位时，（⽐如说左移8位），它会进⾏补全，⽽且是有符号位的补全，再左移8位，所以最后结果是：11111111 11111111 11111111 00000000，但我们因为最后在将byte型数组转换成int型的时候，需要对数组元素使⽤按位或（ | ）操作，因此，移位结果前⾯的符号位如果不去除，将影响我们的运算，得出⼀个错误的结果。

javaByte和byte差别及byte[]和string转换先看Byte，是⼀个类：public final class ByteThe Byte class wraps a value of primitive type byte in an object. An object of type Byte contains a single field whose type is byte.In addition, this class provides several methods for converting a byte to a String and a String to a byte, as well as other constants and methods useful when dealing with a byte.byte是基本数据类型Byte是byte的包装类我们可以看出Byte是⼀个类，byte只是⼀个原始数据类型。

Byte是引⽤类型,byte是值类型(原型), Byte是⼀个类，有很多⽅法，⽅便我们转换为其他类型.转换Byte【】到stringpublic class Main {/** This method converts an byte array to a String object.*/public void convertByteArrayToString() {byte[] byteArray = new byte[] {87, 79, 87, 46, 46, 46};String value = new String(byteArray);System.out.println(value);}/*** @param args the command line arguments*/public static void main(String[] args) {new Main().convertByteArrayToString();}}string 转byte【】String str;byte[] a=str.getBytes[];总结：String s = "fs123fdsa";//String变量byte b[] = s.getBytes();//String转换为byte[]String t = new String(b);//bytep[]转换为String。

Java中的数据类型及相互转换⽅法本⽂主要讲解两个部分： ⼀、Java中的数据类型有哪些？ ⼆、数字类型和字符串类型相互转换的⽅法？⼀、Java中的数据类型有哪些： Java中的数据类型有：基本数据类型和引⽤数据类型； 基本数据类型有：byte、short、int、Long、float、double、char 和 Boolean； 引⽤数据类型有：String、StringBuffer、ArrayList、HashSet 和 HashMap。

⼆、数字类型和字符串类型相互转换的⽅法： 数字类型主要是：byte、short、int、long、float、double这六种。

2.1、数字类型转换成字符串类型的⽅法： 数字类型在Java中都有其相应的类，例如int类型有Integer类，long类型有Long类；它们这些类中都有相应的toString（）⽅法，将相应的数字类型转换为字符串！ String str = Byte.toString(byte); String str = Short.toString(short); String str = Integer.toString(int); String str = Long.toString(long); String str = Float.toString(float); String str = Double.toString(double); 2.1、字符串类型转换成数字类型的⽅法： 数字类型相应的类中都有其相应的⽅法**.parse**(String str)将字符串转换为相应的数字类型！ Byte byte = Byte.parseByte(String str); Short short = Short.parseShort(String str); Integer int = Integer.parseInteger(String str); Long long= Long.parseLong(String str); Float float = Float.parseFloat(String str); Double double = Double.parseDouble(String str);。