java 转字节序

最新推荐文章于 2022-12-14 21:53:20 发布
最新推荐文章于 2022-12-14 21:53:20 发布
阅读量1.3k 收藏
点赞数
文章标签： java byte float string delphi integer
/**
    * 通信格式转换
    *
    * Java和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换
    * 高、低字节之间的转换
    * windows的字节序为低字节开头
    * linux,unix的字节序为高字节开头
    * java则无论平台变化，都是高字节开头
      */  
     
    public class FormatTransfer { 
    /**
      * 将int转为低字节在前，高字节在后的byte数组
      * @param n int
      * @return byte[]
      */ 
    public static byte[] toLH(int n) { 
      byte[] b = new byte[4]; 
      b[0] = (byte) (n & 0xff); 
      b[1] = (byte) (n >> 8 & 0xff); 
      b[2] = (byte) (n >> 16 & 0xff); 
      b[3] = (byte) (n >> 24 & 0xff); 
      return b; 
    }  
     
    /**
      * 将int转为高字节在前，低字节在后的byte数组
      * @param n int
      * @return byte[]
      */ 
    public static byte[] toHH(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; 
    }  
     
    /**
      * 将short转为低字节在前，高字节在后的byte数组
      * @param n short
      * @return byte[]
      */ 
    public static byte[] toLH(short n) { 
      byte[] b = new byte[2]; 
      b[0] = (byte) (n & 0xff); 
      b[1] = (byte) (n >> 8 & 0xff); 
      return b; 
    }  
     
    /**
      * 将short转为高字节在前，低字节在后的byte数组
      * @param n short
      * @return byte[]
      */ 
    public static byte[] toHH(short n) { 
      byte[] b = new byte[2]; 
      b[1] = (byte) (n & 0xff); 
      b[0] = (byte) (n >> 8 & 0xff); 
      return b; 
    }  
     
     
     
    /**
      * 将将int转为高字节在前，低字节在后的byte数组 
   
    public static byte[] toHH(int number) {
      int temp = number;
      byte[] b = new byte[4];
      for (int i = b.length - 1; i > -1; i--) {
        b = new Integer(temp & 0xff).byteValue();
        temp = temp >> 8;
      }
      return b;
    } 
   
    public static byte[] IntToByteArray(int i) {
        byte[] abyte0 = new byte[4];
        abyte0[3] = (byte) (0xff & i);
        abyte0[2] = (byte) ((0xff00 & i) >> 8);
        abyte0[1] = (byte) ((0xff0000 & i) >> 16);
        abyte0[0] = (byte) ((0xff000000 & i) >> 24);
        return abyte0;
    } 
   
   
    */  
     
    /**
      * 将float转为低字节在前，高字节在后的byte数组
      */ 
    public static byte[] toLH(float f) { 
      return toLH(Float.floatToRawIntBits(f)); 
    }  
     
    /**
      * 将float转为高字节在前，低字节在后的byte数组
      */ 
    public static byte[] toHH(float f) { 
      return toHH(Float.floatToRawIntBits(f)); 
    }  
     
    /**
      * 将String转为byte数组
      */ 
    public static byte[] stringToBytes(String s, int length) { 
      while (s.getBytes().length < length) { 
        s += " "; 
      } 
      return s.getBytes(); 
    }  
     
     
    /**
      * 将字节数组转换为String
      * @param b byte[]
      * @return String
      */ 
    public static String bytesToString(byte[] b) { 
      StringBuffer result = new StringBuffer(""); 
      int length = b.length; 
      for (int i=0; i<length; i++) { 
        result.append((char)(b & 0xff)); 
      } 
      return result.toString(); 
    }  
     
    /**
      * 将字符串转换为byte数组
      * @param s String
      * @return byte[]
      */ 
    public static byte[] stringToBytes(String s) { 
      return s.getBytes(); 
    }  
     
    /**
      * 将高字节数组转换为int
      * @param b byte[]
      * @return int
      */ 
    public static int hBytesToInt(byte[] b) { 
      int s = 0; 
      for (int i = 0; i < 3; i++) { 
        if (b >= 0) { 
        s = s + b; 
        } else { 
        s = s + 256 + b; 
        } 
        s = s * 256; 
      } 
      if (b[3] >= 0) { 
        s = s + b[3]; 
      } else { 
        s = s + 256 + b[3]; 
      } 
      return s; 
    }  
     
    /**
      * 将低字节数组转换为int
      * @param b byte[]
      * @return int
      */ 
    public static int lBytesToInt(byte[] b) { 
      int s = 0; 
      for (int i = 0; i < 3; i++) { 
        if (b[3-i] >= 0) { 
        s = s + b[3-i]; 
        } else { 
        s = s + 256 + b[3-i]; 
        } 
        s = s * 256; 
      } 
      if (b[0] >= 0) { 
        s = s + b[0]; 
      } else { 
        s = s + 256 + b[0]; 
      } 
      return s; 
    }  
     
     
    /**
      * 高字节数组到short的转换
      * @param b byte[]
      * @return short
      */ 
    public static short hBytesToShort(byte[] b) { 
      int s = 0; 
      if (b[0] >= 0) { 
        s = s + b[0]; 
        } else { 
        s = s + 256 + b[0]; 
        } 
        s = s * 256; 
      if (b[1] >= 0) { 
        s = s + b[1]; 
      } else { 
        s = s + 256 + b[1]; 
      } 
      short result = (short)s; 
      return result; 
    }  
     
    /**
      * 低字节数组到short的转换
      * @param b byte[]
      * @return short
      */ 
    public static short lBytesToShort(byte[] b) { 
      int s = 0; 
      if (b[1] >= 0) { 
        s = s + b[1]; 
        } else { 
        s = s + 256 + b[1]; 
        } 
        s = s * 256; 
      if (b[0] >= 0) { 
        s = s + b[0]; 
      } else { 
        s = s + 256 + b[0]; 
      } 
      short result = (short)s; 
      return result; 
    }  
     
    /**
      * 高字节数组转换为float
      * @param b byte[]
      * @return float
      */ 
    public static float hBytesToFloat(byte[] b) { 
      int i = 0; 
      Float F = new Float(0.0); 
      i = ((((b[0]&0xff)<<8 | (b[1]&0xff))<<8) | (b[2]&0xff))<<8 | (b[3]&0xff); 
      return F.intBitsToFloat(i); 
    }  
     
    /**
      * 低字节数组转换为float
      * @param b byte[]
      * @return float
      */ 
    public static float lBytesToFloat(byte[] b) { 
      int i = 0; 
      Float F = new Float(0.0); 
      i = ((((b[3]&0xff)<<8 | (b[2]&0xff))<<8) | (b[1]&0xff))<<8 | (b[0]&0xff); 
      return F.intBitsToFloat(i); 
    }  
     
    /**
      * 将byte数组中的元素倒序排列
      */ 
    public static byte[] bytesReverseOrder(byte[] b) { 
      int length = b.length; 
      byte[] result = new byte[length]; 
      for(int i=0; i<length; i++) { 
        result[length-i-1] = b; 
      } 
      return result; 
    }  
     
    /**
      * 打印byte数组
      */ 
    public static void printBytes(byte[] bb) { 
      int length = bb.length; 
      for (int i=0; i<length; i++) { 
        System.out.print(bb + " "); 
      } 
      System.out.println(""); 
    }  
     
    public static void logBytes(byte[] bb) { 
      int length = bb.length; 
      String out = ""; 
      for (int i=0; i<length; i++) { 
        out = out + bb + " "; 
      }  
     
    }  
     
    /**
      * 将int类型的值转换为字节序颠倒过来对应的int值
      * @param i int
      * @return int
      */ 
    public static int reverseInt(int i) { 
      int result = FormatTransfer.hBytesToInt(FormatTransfer.toLH(i)); 
      return result; 
    }  
     
    /**
      * 将short类型的值转换为字节序颠倒过来对应的short值
      * @param s short
      * @return short
      */ 
    public static short reverseShort(short s) { 
      short result = FormatTransfer.hBytesToShort(FormatTransfer.toLH(s)); 
      return result; 
    }  
     
    /**
      * 将float类型的值转换为字节序颠倒过来对应的float值
      * @param f float
      * @return float
      */ 
    public static float reverseFloat(float f) { 
      float result = FormatTransfer.hBytesToFloat(FormatTransfer.toLH(f)); 
      return result; 
    }  
     
    } 
长虹小范
关注
计算机基础：字节序转换
无聊科技
07-27 2270
转载请标明出处：https://blog.csdn.net/qq_29621351/article/details/81238589       字节序，顾名思义就是计算机存储基本数据类型时 字节的排列顺序，计算机存储字节的顺序分为两种：大端字节序和小端字节序，存储方式为 大端字节序的0x11在硬件地址的高位，而小端字节序的0x11在地址的低位。如图 数值：0x11223344 大端：0x1...
java 主机字节序 网络字节序_主机字节序 与 网络字节序
weixin_33896830的博客
02-19 680
一、字节顺序是指占用内存多于一个字节类型的数据在内存中的存放顺序。计算机电路先处理低位字节，效率比较高，因为计算都是从低位开始的。所以，计算机的内部处理都是小端字节序。但是，网络传输、文件储存、人类读写习惯使用大端字节序。java中一个int型数据占用4个字节，假如有一个16进制的int数，int value =(高字节) 0x01020304 (低字节)小端字节序(little endian)：...
【转】Java字节序转换
09-27 2056
源文档     /**     * 通信格式转换     *     * Java和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换     * 高、低字节之间的转换     *
Java字节序转换
weixin_33772645的博客
05-04 946
/***通信格式转换**Java 和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换*高、低字节之间的转换*windows的字节序为低字节开头*linux,unix的字节序为高字节开头*java则无论平台变化，都是高字节开头*/publicclassForma...
1. 字节序的转换
weixin_34144848的博客
08-30 206
一、大端字节序和小端字节序 大端字节序：一个整数的高位字节(23~31bit)存储在内存的低地址处，低位字节(0~7bit)存储在内存的高地址处。 小端字节序：一个整数的高位字节(23~31bit)存储在内存的高地址处，低位字节(0~7bit)存储在内存的低地址处。 现代PC大多采用小端字节序，因此其又被称为主机字节序。 对应的，大端字节序也称为网络字节序。 二、字节序的转...
字节序转换详解
无心的博客
10-18 4881
在跨平台和网络编程中我们经常会提到网络字节序和主机字节序，如果没有正确对两者进行转换，从而导致两方产生了不同的解释，就会出现意想不到的bug。 目录 0x01 概念 0x02 分类 0x03 两种字节序之间的区别 0x01 概念 字节序，就是大于一个字节类型的数据在内存中的存放顺序。 注：网络字节序是TCP/IP中规定好的一种数据表示格式，它与具体的CPU类型、操作系统等无关，从而可以保证数...
JAVA网络字节序转换1
08-08
Java 网络字节序转换是编程过程中一个重要的概念，尤其在跨平台通信和处理二进制数据时。字节序是指多字节数据（如整数或浮点数）在内存或文件中存储的顺序。主要有两种字节序：Big-Endian（大端字节序）和 Little-...
Java整型数与网络字节序byte[]数组转换关系详解
08-29
"Java整型数与网络字节序byte[]数组转换关系详解" 本文主要介绍了Java整型数与网络字节序byte[]数组之间的转换关系，包括整型数到byte[]数组的转换和byte[]数组到整型数的转换。这些转换关系在Java和C/C++之间的...
字节序转换辅助类，字节大端小端转换
最新发布
02-16
字节序转换辅助类，short大小端转换，ushort大小端转换，int大小端转换，uint大小端转换，long大小端转换，ulong大小端转换； short类型 小端转大端，short类型 大端转小端，int类型 小端转大端，int类型 大端转小端...
java 网络字节序转主机字节序
03-30
在Java中，可以使用以下方法将网络字节序转换为主机字节序： 1. 使用ByteBuffer类中的order()方法设置字节序为网络字节序： ``` ByteBuffer buffer = ByteBuffer.wrap(bytes); // bytes为网络字节序数据 buffer....
Java_NetWork_Endianness-字节序
CodingMan
05-18 3230
Endianness-字节序维基百科：http://zh.wikipedia.org/wiki/%E5%AD%97%E8%8A%82%E5%BA%8F
Java大字节顺转换小字节顺
坚持学习
02-29 695
前言  本文主要介绍 如何将大字节顺转为小字节顺 ，至于什么大字节顺和小字节顺可以百度 java 默认获取的字节顺为大字节顺，在做私有通信协议的时候 需要转换为小字节顺（主要是做服务器的大哥是写c#的） 转换代码如下： /** * 数组反转 * java获取的字节顺为大字节顺 需要转为小字节顺 所以需要对数组反转 * @param by
字节序转换
yu17671636097的博客
12-14 695
字节序转换
Java字节序
热门推荐
Jason
01-04 1万+
　以下对BIG-ENDIAN、LITTLE-ENDIAN的解释正好弄反了！！！！　　BIG-ENDIAN（大字节序、高字节序）　　LITTLE-ENDIAN（小字节序、低字节序）　　主机字节序　　网络字节顺序　　JAVA字节序　　1．BIG-ENDIAN、LITTLE-ENDIAN跟多字节类型的数据有关的比如int,short,long型，而对单字节数据byte却没有影响。BIG-ENDIAN就是
Java中的字节序问题
WSJ ' Blog
01-03 3702
Java中的字节序问题
htons函数详解
wenwen_2008的专栏
06-01 2553
Part 1: htons函数具体解释      在Linux和Windows网络编程时需要用到htons和htonl函数，用来将主机字节顺序转换为网络字节顺序。      在Intel机器下，执行以下程序 int main() ...{    printf("%d /n",htons(16));       return 0; } 得到的结果是4096，初一看感觉很怪。
java整型数与网络字节序的转换
聆听梦飞扬的博客
10-29 681
java整型数与网络字节序的转换 /** * java整型数与网络字节序的 byte[] 数组转换关系 * 工作项目需要在java和c/c++之间进行socket通信，socket通信是以字节流或者字节包进行的，socket发送方须将数据转换为字节流或者字节包， * 而接收方则将字节流和字节包再转换回相应的数据类型。如果发送方和接收方都是同种语言，则一般只涉及到字节序的调整。而对于java和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值