delphi与java 类型转换_JAVA基本数据类型与其他语言数据类型之间的转换方法

今天笔试中java题： (1) public static void main (String []args) { Integer a  = new Integer(1); Integer b  = new Integer(1); int c  = 1; Integer e = 1; System.out.println("a==b:"+(a==b)); System.out.println("a==c:"+(a==c));  System.out.prin

/**

* 通信格式转换

*

* 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 1个字节(主要是节省内存控件,在进行i/o传输的时候可以使用) short 2个字节(不常用) int 4个字节(常用于控制循环语句) long 8个字节(计算非常大的数是,int不足以满足容纳大小，如果long还不够就是用BigInteger) char 2个字节(Java使用Unicode字符集表示字低字节在后的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

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

result[length-i-1] = b;

}

return result;

}

/**

* 打印byte数组

*/

public static void printBytes(byte[] bb) {

int length = bb.length;

for (int i=0; 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

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;

}

}