Java 与 C 底层数据类型转换

importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.IOException;

/**
*仅仅适用于Java与C++通讯中，网络流解析与生成使用
*
*高低位互换(Big-Endian大头在前&Little-Endian小头在前)。
*举例而言，有一个4字节的数据0x01020304，要存储在内存中或文件中编号0˜3字节的位置，两种字节序的排列方式分别如下：
*<pre>
*BigEndian
*
*低地址高地址
*----------------------------------------------------&gt;
*地址编号
*|0|1|2|3|
*+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*|01|02|03|04|
*+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
*LittleEndian
*
*低地址高地址
*----------------------------------------------------&gt;
*地址编号
*|0|1|2|3|
*+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*|04|03|02|01|
*+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*</pre>
*Java则统一使用big模式
*c中的unsignedshort对应着java中的char两个字节，无符号
*c的无符号int,short,byte字节数组，相应转换成java的long,char,short
*
*@authorSnowolf
*@version1.0
*@since1.0
*/
publicabstractclassCIOUtil{
publicstaticfinalStringCHARSET="UTF-8";

/**
*从输入流中读布尔
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticbooleanreadBoolean(DataInputStreamis)throwsIOException{
returnis.readBoolean();
}

/**
*从流中读定长度字节数组
*
*@paramis
*@params
*@return
*@throwsIOException
*/
publicstaticbyte[]readBytes(DataInputStreamis,inti)
throwsIOException{
byte[]data=newbyte[i];
is.readFully(data);

returndata;
}

/**
*从输入流中读字符
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticcharreadChar(DataInputStreamis)throwsIOException{
return(char)readShort(is);
}

/**
*从输入流中读双精度
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticdoublereadDouble(DataInputStreamis)throwsIOException{
returnDouble.longBitsToDouble(readLong(is));
}

/**
*从输入流中读单精度
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticfloatreadFloat(DataInputStreamis)throwsIOException{
returnFloat.intBitsToFloat(readInt(is));
}

/**
*从流中读整型
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticintreadInt(DataInputStreamis)throwsIOException{
returnInteger.reverseBytes(is.readInt());
}

/**
*从流中读长整型
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticlongreadLong(DataInputStreamis)throwsIOException{
returnLong.reverseBytes(is.readLong());
}

/**
*从流中读短整型
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticshortreadShort(DataInputStreamis)throwsIOException{
returnShort.reverseBytes(is.readShort());
}

/**
*从输入流中读字符串字符串结构为一个指定字符串字节长度的短整型+实际字符串
*
*@paramis
*@return
*@throwsIOException
*/
publicstaticStringreadUTF(DataInputStreamis)throwsIOException{
shorts=readShort(is);
byte[]str=newbyte[s];

is.readFully(str);

returnnewString(str,CHARSET);
}

/**
*向输出流中写布尔
*
*@paramos
*@paramb
*@throwsIOException
*/
publicstaticvoidwriteBoolean(DataOutputStreamos,booleanb)
throwsIOException{
os.writeBoolean(b);
}

/**
*向输出流中写字节数组
*
*@paramos
*@paramdata
*@throwsIOException
*/
publicstaticvoidwriteBytes(DataOutputStreamos,byte[]data)
throwsIOException{
os.write(data);
}

/**
*向输出流中写字符
*
*@paramos
*@paramb
*@throwsIOException
*/
publicstaticvoidwriteChar(DataOutputStreamos,charb)
throwsIOException{
writeShort(os,(short)b);
}

/**
*向输出流中写双精度
*
*@paramos
*@paramd
*@throwsIOException
*/
publicstaticvoidwriteDouble(DataOutputStreamos,doubled)
throwsIOException{
writeLong(os,Double.doubleToLongBits(d));
}

/**
*向输出流中写单精度
*
*@paramos
*@paramf
*@throwsIOException
*/
publicstaticvoidwriteFloat(DataOutputStreamos,floatf)
throwsIOException{
writeInt(os,Float.floatToIntBits(f));
}

/**
*向输出流中写整型
*
*@paramos
*@parami
*@throwsIOException
*/
publicstaticvoidwriteInt(DataOutputStreamos,inti)throwsIOException{
os.writeInt(Integer.reverseBytes(i));
}

/**
*向输出流中写长整型
*
*@paramos
*@paraml
*@throwsIOException
*/
publicstaticvoidwriteLong(DataOutputStreamos,longl)
throwsIOException{
os.writeLong(Long.reverseBytes(l));
}

/**
*向输出流中写短整型
*
*@paramos
*@params
*@throwsIOException
*/
publicstaticvoidwriteShort(DataOutputStreamos,shorts)
throwsIOException{
os.writeShort(Short.reverseBytes(s));
}

/**
*向输出流中写字符串字符串结构为一个指定字符串字节长度的短整型+实际字符串
*
*@paramos
*@paramstr
*@throwsIOException
*/
publicstaticvoidwriteUTF(DataOutputStreamos,Stringstr)
throwsIOException{
byte[]data=str.getBytes(CHARSET);
writeShort(os,(short)data.length);
os.write(data);
}

}

再写个测试类

importjava.io.ByteArrayInputStream;
importjava.io.ByteArrayOutputStream;
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.IOException;

importorg.junit.Test;
importstaticorg.junit.Assert.*;

/**
*
*@authorSnowolf
*@version1.0
*@since1.0
*/
publicclassCIOUtilTest{
/**
*测试布尔值
*
*@throwsIOException
*/
@Test
publicfinalvoidtestBoolean()throwsIOException{
booleaninput=true;
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeBoolean(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

booleanoutput=CIOUtil.readBoolean(is);

bais.close();

assertEquals(input,output);
}

/**
*测试字节数组
*
*@throwsIOException
*/
@Test
publicfinalvoidtestBytes()throwsIOException{
byte[]input="中文".getBytes("UTF-8");
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeBytes(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

byte[]output=CIOUtil.readBytes(is,6);

bais.close();

assertArrayEquals(input,output);
}

/**
*测试字符
*
*@throwsIOException
*/
@Test
publicfinalvoidtestChar()throwsIOException{
charinput='中';
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeChar(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

charoutput=CIOUtil.readChar(is);

bais.close();

assertEquals(input,output);
}

/**
*测试双精度
*
*@throwsIOException
*/
@Test
publicfinalvoidtestDouble()throwsIOException{
doubleinput=1.23456789d;
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeDouble(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

doubleoutput=CIOUtil.readDouble(is);

bais.close();

assertEquals(input,output,9);
}

/**
*测试单精度
*
*@throwsIOException
*/
@Test
publicfinalvoidtestFloat()throwsIOException{
floatinput=1.23456789f;
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeFloat(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

floatoutput=CIOUtil.readFloat(is);

bais.close();

assertEquals(input,output,9);
}

/**
*测试整型
*
*@throwsIOException
*/
@Test
publicfinalvoidtestInt()throwsIOException{
intinput=1;
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeInt(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

intoutput=CIOUtil.readInt(is);

bais.close();

assertEquals(input,output);
}

/**
*测试长整型
*
*@throwsIOException
*/
@Test
publicfinalvoidtestLong()throwsIOException{
longinput=1l;
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeLong(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

longoutput=CIOUtil.readLong(is);

bais.close();

assertEquals(input,output);
}

/**
*测试短整型
*
*@throwsIOException
*/
@Test
publicfinalvoidtestShort()throwsIOException{
shortinput=1;
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeShort(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

shortoutput=CIOUtil.readShort(is);

bais.close();

assertEquals(input,output);
}

/**
*测试UTF-8字符串
*
*@throwsIOException
*/
@Test
publicfinalvoidtestUTF()throwsIOException{
Stringinput="中文支持";
ByteArrayOutputStreambaos=newByteArrayOutputStream();
DataOutputStreamos=newDataOutputStream(baos);

CIOUtil.writeUTF(os,input);

byte[]b=baos.toByteArray();
baos.flush();
baos.close();

ByteArrayInputStreambais=newByteArrayInputStream(b);
DataInputStreamis=newDataInputStream(bais);

Stringoutput=CIOUtil.readUTF(is);

bais.close();

assertEquals(input,output);
}

}