war_martin
- 浏览: 115323 次
- 性别:
- 来自: 北京
-
最新评论
-
zhaoljin：
棒棒的
spring3.0事务管理配置 -
nevergiveup_che：
emp%ROWTYPE 楼主，这个emp 是在哪定义的啊，怎么 ...
oracle动态游标实例 -
hala-Gaga：
说得好！给力！谢谢！
spring3.0事务管理配置 -
zyhui98：
写的很好，顶。
spring3.0事务管理配置 -
q821424508：
3Q 今天用到了
java 判断中文字符串长度
java socket通信数据类型转换(与C语言通信)
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 longToBytes( 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[] uintToBytes( 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 uintToBytes( 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 shortToBytes(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[] 数组之间的转换关系还需继续研究实现。
}
测试程序如下：
public class ByteConvertTest {
public static String byte2Hex(byte[] buf)
{
StringBuffer strbuf = new StringBuffer();
strbuf.append("{");
for (byte b : 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("}");
return strbuf.toString();
}
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 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(byte b[]) {
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( 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 byte[] shortToBytes(short n) {
byte[] b = new byte[2];
b[1] = (byte) ( n & 0xff);
b[0] = (byte) ((n >> 8) & 0xff);
return b;
}
public static short bytesToShort(byte[] b){
return (short)( b[1] & 0xff
|(b[0] & 0xff) << 8 );
}
static void testShortConvert(){
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(int n) {
byte[] b = new byte[2];
b[1] = (byte) (n & 0xff);
b[0] = (byte) (n >> 8 & 0xff);
return b;
}
public static int bytesToUshort(byte b[]) {
return b[1] & 0xff
| (b[0] & 0xff) << 8;
}
static void testUshortConvert(){
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( int n ){
byte[] b = new byte[1];
b[0] = (byte) (n & 0xff);
return b;
}
public static int bytesToUbyte( byte[] array ){
return array[0] & 0xff;
}
static void testUbyteConvert(){
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)));
}
/**
* @param args
*/
public static void main(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();
}
}
分享到：
发表评论
相关推荐
描述：为了解决java与C结构通信过程中结构体解析问题。 主要功能：能友好的用java处理任何发送的C结构体对象，并且能发送java对象转换成C结构体接收的二进制。 功能说明 1、基于spring框架开发 2、对于结构体定义...
总结起来，Java解析Linux C语言结构体消息是一个涉及网络编程、数据类型转换和二进制数据处理的复杂任务。正确完成这一过程需要对Java和C语言的内存模型有深入理解，以及对网络通信协议的熟悉。只有这样，才能确保...
- 类似的映射关系还有更多，确保数据类型的正确转换是实现数据交换的关键。 - **实现步骤**： 1. 在Java代码中声明本地方法。 2. 使用`javah`工具生成C/C++头文件。 3. 编写C/C++函数来实现这些本地方法。 4. ...
结构体是在C语言中创建复杂数据类型的工具，可以通过结构体将不同类型的数据组合在一起，以便于管理和操作。 5. Qt框架 Qt是一个跨平台的应用程序和用户界面框架，用于C++开发图形用户界面程序，以及非GUI程序，如...
1. **基本语法**：包括变量声明、数据类型、运算符、流程控制（if-else, switch-case, for, while等）。 2. **函数**：定义和调用函数，理解参数传递和返回值。 3. **输入/输出**：使用`printf`和`scanf`进行标准...
1. **变量与数据类型**：了解如何声明和使用各种基本数据类型，如int、float、char等，以及如何进行类型转换。 2. **运算符与表达式**：掌握算术、关系、逻辑和位运算符，理解运算优先级和表达式的求值。 3. **...
Java学习与基础知识详解 在Java学习的道路上，掌握基础至关重要。本资料集合涵盖了从C语言的基础，到Java的常用类，再到计算机进制和计算机网络的相关知识，为初学者提供了全面的学习路径。以下是对这些关键知识点...
- **java.net**：网络通信包，支持Socket、ServerSocket等网络编程。 - **java.util**：通用工具包，包括集合框架、日期时间处理和泛型等。 - **java.sql**：数据库连接和操作的接口，如Connection、Statement和...
【标题】：“cyuyanjiaocheng”课程资料——C语言程序设计与J2EE教程 【描述】：这份教学资料主要涵盖了C语言...通过编写IDL文件，用户可以描述操作、参数和数据类型，从而屏蔽不同编程语言的差异，实现跨平台的通信。
- **4.2 服务器与客户端通信** 服务器端通常需要绑定一个地址到套接字上，然后监听连接请求。客户端则需要连接到服务器端的地址。接下来，双方可以通过读写操作进行通信。 服务器端代码示例： ```c int ...
- **定义**：socket是一种进程间通信机制，用于在网络中的不同计算机之间传输数据。 - **作用**：实现不同进程之间的数据交换，无论是同一台计算机还是不同计算机上的进程。 2. **Socket类型**： - **流式套接字...
在实际项目中，结合TCP/IP网络编程，可以使用SOCKET API或者更高级的库如libevent、libuv来处理网络连接和数据传输。同时，为了简化开发，可以考虑使用已有的SIP栈，如PJSIP、Mobicents或OpenSIPS，这些库提供了更...
"VC常用数据类型使用转换详解.htm"可能涉及了C++中的基本数据类型，如int、char、float、double，以及它们之间的转换规则。在编程时，正确理解和使用这些类型对于避免溢出和精度问题至关重要。此外，还可能讲解了...
注意：默认类型转换(自动类型提升)会丢失精度，但只有三种情况： int>float; long>float; long>double. 看一下他们的有效位就明白。 二进制是无法精确的表示 0.1 的。 进行高精度运算可以用java.math包中...
这些头文件提供了 Socket 编程所需的各种数据类型和函数定义。 ##### 3.2 编译和链接 大多数 UNIX 系统（如 Linux、BSD、SunOS 和 IRIX）中的编译命令如下： ```bash gcc my_socket_program.c -o my_socket_...
- **错误**：`s1=s1+1`会导致类型转换错误。 - **正确**：`s1+=1`会自动提升类型，然后赋值。 #### 29. sleep()和wait()有什么区别? - **sleep()**：线程暂停执行指定时间，释放CPU但不释放锁。 - **wait()**：...
在Java中，TCP通信的客户端程序通常使用`Socket`类来实现。例如，`B. Socket`是正确的选择。 【知识点3】：二进制与十进制转换 8位二进制数的最大无符号整数是11111111，转换成十进制为255。因此，答案是A.255。 ...
- **知识点**: Java中的类型转换与编码实践。 - **详细说明**: 给定代码片段中，`char a = 'h'; int i = 100;`，`char`类型的`a`加上`int`类型的`i`得到的结果为整数类型。因此，`aa = h + 100`，字符`h`的ASCII码为...
8. **浮点型数据类型**：Java中的浮点类型分为float和double，其中double具有更高的精度和更大的存储空间。 9. **字段类型**：在数据库中，自动编号是一种特殊的字段类型，通常用于自动生成唯一的记录标识，不能被...
- 掌握数组/指针用法：学习指针的类型、运算、表达式、类型转换等，以及数组越界判断。 - 内存管理：包括内存组织方式、内存泄露排查、自定义内存池（memory pool）以及使用该内存池编写示例程序。 - 常用C库函数...