java 网络字节序_网路搜集：java整型数与网络字节序的 byte[] 数组转换关系

最新推荐文章于 2023-02-16 14:21:16 发布
最新推荐文章于 2023-02-16 14:21:16 发布
阅读量95 收藏
点赞数
文章标签： java 网络字节序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39795479/article/details/114060228
版权

public classByteConvert {//以下 是整型数 和 网络字节序的 byte[] 数组之间的转换

public static byte[] longToBytes(longn) {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);returnb;

}public static void longToBytes( long n, byte[] array, intoffset ){

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, intoffset )

{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(intn) {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);returnb;

}public static void intToBytes( int n, byte[] array, intoffset ){

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(byteb[]) {return b[3] & 0xff

| (b[2] & 0xff) << 8

| (b[1] & 0xff) << 16

| (b[0] & 0xff) << 24;

}public static int bytesToInt(byte b[], intoffset) {return b[offset+3] & 0xff

| (b[offset+2] & 0xff) << 8

| (b[offset+1] & 0xff) << 16

| (b[offset] & 0xff) << 24;

}public static byte[] uintToBytes( longn )

{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);returnb;

}public static void uintToBytes( long n, byte[] array, intoffset ){

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, intoffset) {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(shortn) {byte[] b = new byte[2];

b[1] = (byte) ( n & 0xff);

b[0] = (byte) ((n >> 8) & 0xff);returnb;

}public static void shortToBytes(short n, byte[] array, intoffset ) {

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, intoffset){return (short)( b[offset+1] & 0xff

|(b[offset] & 0xff) << 8);

}public static byte[] ushortToBytes(intn) {byte[] b = new byte[2];

b[1] = (byte) ( n & 0xff);

b[0] = (byte) ((n >> 8) & 0xff);returnb;

}public static void ushortToBytes(int n, byte[] array, intoffset ) {

array[offset+1] = (byte) ( n & 0xff);

array[offset]= (byte) ((n >> 8) & 0xff);

}public static int bytesToUshort(byteb[]) {return b[1] & 0xff

| (b[0] & 0xff) << 8;

}public static int bytesToUshort(byte b[], intoffset) {return b[offset+1] & 0xff

| (b[offset] & 0xff) << 8;

}public static byte[] ubyteToBytes( intn ){byte[] b = new byte[1];

b[0] = (byte) (n & 0xff);returnb;

}public static void ubyteToBytes( int n, byte[] array, intoffset ){

array[0] = (byte) (n & 0xff);

}public static int bytesToUbyte( byte[] array ){return array[0] & 0xff;

}public static int bytesToUbyte( byte[] array, intoffset ){return array[offset] & 0xff;

}//char 类型、 float、double 类型和 byte[] 数组之间的转换关系还需继续研究实现。

}

测试程序如下：public classByteConvertTest {public static String byte2Hex(byte[] buf)

{

StringBuffer strbuf= newStringBuffer();

strbuf.append("{");for (byteb : buf)

{if (b == 0)

{

strbuf.append("00");

}else if (b == -1)

{

strbuf.append("FF");

}else{

String str=Integer.toHexString(b).toUpperCase();//sb.append(a);

if (str.length() == 8)

{

str= str.substring(6, 8);

}else if (str.length() < 2)

{

str= "0" +str;

}

strbuf.append(str);

}

strbuf.append(" ");

}

strbuf.append("}");returnstrbuf.toString();

}public static byte[] longToBytes(longn) {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);returnb;

}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) ));

}public static int bytesToInt(byteb[]) {return b[3] & 0xff

| (b[2] & 0xff) << 8

| (b[1] & 0xff) << 16

| (b[0] & 0xff) << 24;

}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 byte[] uintToBytes( longn )

{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);returnb;

}public static byte[] shortToBytes(shortn) {byte[] b = new byte[2];

b[1] = (byte) ( n & 0xff);

b[0] = (byte) ((n >> 8) & 0xff);returnb;

}public static short bytesToShort(byte[] b){return (short)( b[1] & 0xff

|(b[0] & 0xff) << 8);

}static voidtestShortConvert(){

System.out.println("=================== short convert =============");

System.out.println("byte2Hex(shortToBytes((short)0x11f2))"+byte2Hex(shortToBytes((short)0x11f2)));

System.out.print("println 0x11f2:");

System.out.println((short)0x11f2);

System.out.println("byte2Hex(shortToBytes((short)0xf1f2))"+byte2Hex(shortToBytes((short)0xf1f2)));

System.out.print("println 0xf1f2:");

System.out.println((short)0xf1f2);

System.out.print("println bytesToShort(shortToBytes((short)0x11f2)):");

System.out.println((short)bytesToShort(shortToBytes((short)0x11f2)));

System.out.print("println bytesToShort(shortToBytes((short)0xf1f2)):");

System.out.println((short)bytesToShort(shortToBytes((short)0xf1f2)));

}public static byte[] ushortToBytes(intn) {byte[] b = new byte[2];

b[1] = (byte) (n & 0xff);

b[0] = (byte) (n >> 8 & 0xff);returnb;

}public static int bytesToUshort(byteb[]) {return b[1] & 0xff

| (b[0] & 0xff) << 8;

}static voidtestUshortConvert(){

System.out.println("=================== Ushort convert =============");

System.out.println("byte2Hex(ushortToBytes(0x11f2))"+byte2Hex(ushortToBytes(0x11f2)));

System.out.print("println 0x11f2:");

System.out.println(0x11f2);

System.out.println("byte2Hex(ushortToBytes(0xf1f2))"+byte2Hex(ushortToBytes(0xf1f2)));

System.out.print("println 0xf1f2:");

System.out.println(0xf1f2);

System.out.print("println bytesToUshort(ushortToBytes(0x11f2)):");

System.out.println(bytesToUshort(ushortToBytes(0x11f2)));

System.out.print("println bytesToUshort(ushortToBytes(0xf1f2)):");

System.out.println(bytesToUshort(ushortToBytes(0xf1f2)));

}public static byte[] ubyteToBytes( intn ){byte[] b = new byte[1];

b[0] = (byte) (n & 0xff);returnb;

}public static int bytesToUbyte( byte[] array ){return array[0] & 0xff;

}static voidtestUbyteConvert(){

System.out.println("=================== Ubyte convert =============");

System.out.println("byte2Hex(ubyteToBytes(0x1112))"+byte2Hex(ubyteToBytes(0x1112)));

System.out.print("println 0x1112:");

System.out.println(0x1112);

System.out.println("byte2Hex(ubyteToBytes(0xf2))"+byte2Hex(ubyteToBytes(0xf2)));

System.out.print("println 0xf2:");

System.out.println(0xf2);

System.out.print("println bytesToUbyte(ubyteToBytes(0x1112)):");

System.out.println(bytesToUbyte(ubyteToBytes(0x1112)));

System.out.print("println bytesToUbyte(ubyteToBytes(0xf1f2)):");

System.out.println(bytesToUbyte(ubyteToBytes(0xf1f2)));

}/***@paramargs*/

public static voidmain(String[] args) {//TODO Auto-generated method stub

byte[] array = new byte[4];

array[3] = (byte) 0xF4;

array[2] = 0x13;

array[1] = 0x12;

array[0] = 0x11;

System.out.println("=================== Integer bytes =============");

System.out.println("the bytes is:"+byte2Hex(array) );

System.out.print("println bytesToInt :");

System.out.println( bytesToInt(array));

System.out.printf("printf bytesToInt :%X\n", bytesToInt(array));

System.out.println("=================== long bytes =============");byte[] longBytes = new byte[8];

longBytes[7] = (byte) 0xf7;

longBytes[6] = (byte) 0x16;

longBytes[5] = (byte) 0xf5;

longBytes[4] = (byte) 0x14;

longBytes[3] = (byte) 0xf3;

longBytes[2] = (byte) 0x12;

longBytes[1] = (byte) 0xf1;

longBytes[0] = (byte) 0x10;

System.out.println("the bytes is:"+byte2Hex(longBytes) );

System.out.printf("printf bytesToLong:%X\n",bytesToLong(longBytes));

System.out.println("=================byte to long ================");byte b = (byte)0xf1;

System.out.print("Println the byte:");

System.out.println(b);

System.out.printf("Printf the byte:%X\n",b);long l =b;

System.out.print("Println byte to long:");

System.out.println(l);

System.out.printf("printf byte to long:%X\n",l);

System.out.println("================= uint Bytes ================");byte[] uint = new byte[4];

uint[3] = (byte) 0xf3;

uint[2] = (byte) 0x12;

uint[1] = (byte) 0xf1;

uint[0] = (byte) 0xFF;

System.out.println("the bytes is:"+byte2Hex(uint) );

System.out.printf("printf bytesToUint:%X\n",bytesToUint(uint));

System.out.print("Println bytesToUint:");

System.out.println(bytesToUint(uint));

System.out.println("byte2Hex(uintToBytes(0x11f2f3f4f5f6f7f8l)):"+byte2Hex(uintToBytes(0x11f2f3f4f5f6f7f8l)));

System.out.println("===============Long Integer==============");

System.out.print("println 0x11f2f3f4f5f6f7f8l:");

System.out.println(0x11f2f3f4f5f6f7f8l);

System.out.printf("Printf 0x11f2f3f4f5f6f7f8l:%X\n",0x11f2f3f4f5f6f7f8l);

System.out.println("println byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l))"+byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l)));//注意，下面的这行，并不能获得正确的uint。

System.out.printf("printf bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l):%X\n",bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l)));

System.out.println("===============bytesToLong(longToBytes())==============");

System.out.println(bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));

System.out.printf("%X\n",bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));

testShortConvert();

testUshortConvert();

testUbyteConvert();

}

}

weixin_39795479
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java整型数与网络字节序byte[]数组转换关系详解
08-29
本文主要介绍了Java整型数与网络字节序byte[]数组之间的转换关系，包括整型数到byte[]数组的转换和byte[]数组到整型数的转换。这些转换关系在Java和C/C++之间的socket通信中非常重要，因为它们需要在不同的语言和...
java byte(字节_Java字节序,java整型数与网络字节序 byte[] 数组转换关系(ByteArrayOutpu......
weixin_39738152的博客
02-28 430
/***通信格式转换**Java和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换*高、低字节之间的转换*windows的字节序为低字节开头*linux,unix的字节序为高字节开头*java则无论平台变化，都是高字节开头*/publicclassFormatTransfer{/***将int转为低字节在前，高字节在后的byte数组*...
如何在Java中将字节数组转换为十六进制字符串？
p15097962069的博客
01-07 2535
我有一个用十六进制数字填充并打印的字节数组，简单的方法是毫无意义的，因为有许多不可打印的元素。 我需要的是以下形式的确切十六进制代码： 3a5f771c
字节和数字相互转化
aidou1314的博客
10-26 2172
参考网址：字节和数字相互转化_ljty_sy的博客-CSDN博客_数字转字节 package com.test.util; /** * @title 字节和数字相互转化 */ public class NumberUtil { /** * int整数转换为4字节的byte数组 * * @param i 整数 * @return byte数组 */ public static byte[] intToByte4(int i) {
java byte 16_Java中byte与16进制字符串的互换原理
weixin_30019895的博客
02-16 596
我们都知道Java中的byte是由8个bit组成的，而16进制即16中状态，它是由4个bit来表示的，因为24=16。所以我们可以把一个byte转换成两个用16进制字符，即把高4位和低4位转换成相应的16进制字符，并组合这两个16进制字符串，从而得到byte的16进制字符串。同理，相反的转换也是将两个16进制字符转换成一个byte。转换的函数如下：/*** Convert byte[] to h...
java int转byte出现负数 byte转int的解决
chenhao0568的专栏
05-29 8644
1.java中  byte转int (特别注意) byte b=0x01; int a=0xff&b;  //正确 2. java中 int转byte int a=0x01; byte b=(byte)(a); 原因：java中byte是8位  -128~127之间,而int是32bit，在转化前需将高24位置零，这样就不会出现补码导致的转换错误。
Java 字节数组类型(byte[])与int类型互转方法
08-31
在处理二进制数据时，特别是网络通信或序列化过程中，我们经常需要将整型(int)数据转换为字节数组(byte[])，反之亦然。本文将详细讲解如何在Java中进行这两种类型的转换，并解释相关原理。 1. **int类型转byte[]** ...
Java基本类型与byte数组之间相互转换方法
09-01
有时在处理数据时，我们需要将这些基本类型与字节数组（byte arrays）进行转换，特别是在网络通信、文件存储或序列化等场景中。下面我们将详细介绍如何在Java中进行这种转换。 首先，我们要理解字节在计算机内存中...
BIT_BYTE.zip_数组转换
09-14
本示例"BIT_BYTE.zip_数组转换"着重探讨了如何在程序中实现整型(int)数组与字符(char)数组之间的转换。这种转换在处理二进制数据、字符串编码、以及与硬件交互等场景中十分常见。 一、整型数组到字符数组的转换 1....
在Java中int和byte[]的相互转换
09-01
在Java编程语言中，有时我们需要将整型(int)数据与字节数组(byte[])之间进行转换，这在处理网络通信、序列化或存储数据时尤为常见。本文将深入探讨Java中int与byte[]的转换方法。 首先，让我们理解为什么需要进行...
Java字节序转换
weixin_33772645的博客
05-04 934
/***通信格式转换**Java 和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换*高、低字节之间的转换*windows的字节序为低字节开头*linux,unix的字节序为高字节开头*java则无论平台变化，都是高字节开头*/publicclassForma...
Java网络编程中的字节流传输时输出为负数输出读取却为正数
yq15797688367的博客
07-15 1353
在使用socket编程时，发现服务端通过字节输出流输出一个负数，而客户端读入的却是一个正数。比如-1变成了255,-128变成了128，-126变成了130
Java的大端小端字节序
最新发布
p7+的博客
02-16 1998
在进行网络传输时，需要进行字节序转换，将大端字节序转换成小端字节序，或将小端字节序转换成大端字节序。在计算机中，内存地址通常是按照地址递增的方式分配的，也就是说，低地址是指内存的起始位置，高地址是指内存的末尾位置。小端字节序：在小端字节序中，一个多字节数据的低位字节存储在低地址处，而高位字节存储在高地址处。也就是说，字节的排列顺序是从左到右，低位字节在前，高位字节在后。大端字节序：在大端字节序中，一个多字节数据的高位字节存储在低地址处，而低位字节存储在高地址处。这两个概念的区别在于字节存储的顺序。
java 网络字节序_Java整型数与网络字节序byte[]数组转换关系详解
weixin_33328836的博客
02-12 374
本文实例讲述了Java整型数与网络字节序byte[]数组转换关系。分享给大家供大家参考，具体如下：工作项目需要在java和c/c++之间进行socket通信，socket通信是以字节流或者字节包进行的，socket发送方须将数据转换为字节流或者字节包，而接收方则将字节流和字节包再转换回相应的数据类型。如果发送方和接收方都是同种语言，则一般只涉及到字节序的调整。而对于java和c/c++的通信，则情...
java编程语言的数据类型_Java 的数据类型（学习 Java 编程语言 009）
weixin_34835735的博客
02-25 139
Java 共有 8 种基本类型(Primitive type)，其中有 4 种整型、2 种浮点型、1 种字符类型 char 和 1 种 boolean 类型。在 Java 中，所有的数值类型所占据的字节数量与平台无关。1. 整型整型用于表示没有小数部分的数值，它允许是负数。Java 提供了 4 种整型：byte、short、int 和 long。类型存储需求取值范围byte1 字节-128 ~ 1...
将ushort改装为byte的快捷方法
超胆孤侠
01-14 1013
【代码】将ushort改装为byte的快捷方法。
byte java 详解_详解java中的byte类型
weixin_35027153的博客
02-12 3344
Java也提供了一个byte数据类型，并且是基本类型。java byte是做为最小的数字来处理的，因此它的值域被定义为-128~127，也就是signed byte。下面这篇文章主要给大家介绍了关于java中byte类型的相关资料，需要的朋友可以参考下。介绍byte，即字节，由8位的二进制组成。在Java中，byte类型的数据是8位带符号的二进制数。在计算机中，8位带符号二进制数的取值范围是[-1...
Java整型数与网络字节序转换完全解析
"本文详细介绍了Java整型数与网络字节序byte[]数组之间的转换关系，提供了转换函数，便于Java和C/C++之间的socket通信。" 在计算机网络中，数据在网络中传输时通常以字节流的形式进行，网络字节序（Big-Endian）是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值