Java类型转换(int - byte[],float - byte[])

有符号字节转成无符号字节 java int 转成 byte

[java] view
plain copy

int unsignedByte = signedByte >= 0 ? signedByte :256 + signedByte;

int byteValue;

int temp = intValue % 256;

f ( intValue < 0) {

byteValue = temp < -128 ?256 + temp : temp;

}

else {

byteValue = temp > 127 ? temp -256 : temp;

}

float -> byte[]

先用 Float.floatToIntBits(f)转换成int

再通过如下方法转成byte []

int -> byte[]

[java] view
plain copy

/**

* 将int类型的数据转换为byte数组

* 原理：将int数据中的四个byte取出，分别存储

* @param n int数据

* @return 生成的byte数组

*/

public static byte[] intToBytes2(int n){

byte[] b = new byte[4];

for(int i = 0;i < 4;i++){

b[i] = (byte)(n >> (24 - i * 8));

}

return b;

}

byte[] -> int

/**

* 将byte数组转换为int数据

* @param b 字节数组

* @return 生成的int数据

*/

public static int byteToInt2(byte[] b){

return (((int)b[0]) << 24) + (((int)b[1]) << 16) + (((int)b[2]) << 8) + b[3];

}

}

byte[] -> float

[java] view
plain copy

public static float getFloat(byte[] b) {

// 4 bytes

int accum = 0;

for ( int shiftBy = 0; shiftBy < 4; shiftBy++ ) {

accum |= (b[shiftBy] & 0xff) << shiftBy * 8;

}

return Float.intBitsToFloat(accum);

}

java的int、char、long、float、double对byte的转换

老物，，在通信的时候会用到

http://xuliduo.iteye.com/blog/1126957

[java] view
plain copy

1.package com.util;

2.

3./**

4. *

5. * <ul>

6. * <li>文件名称: com.born.util.ByteUtil.java</li>

7. * <li>文件描述: byte转换工具</li>

8. * <li>版权所有: 版权所有(C)2001-2006</li>

9. * <li>公 司: bran</li>

10. * <li>内容摘要:</li>

11. * <li>其他说明:</li>

12. * <li>完成日期：2011-7-18</li>

13. * <li>修改记录0：无</li>

14. * </ul>

15. *

16. * @version 1.0

17. * @author 许力多

18. */

19.public class ByteUtil {

20. /**

21. * 转换short为byte

22. *

23. * @param b

24. * @param s

25. * 需要转换的short

26. * @param index

27.

28. */

29. public static void putShort(byte b[], short s, int index) {

30. b[index + 1] = (byte) (s >> 8);

31. b[index + 0] = (byte) (s >> 0);

32. }

33.

34. /**

35. * 通过byte数组取到short

36. *

37. * @param b

38. * @param index

39. * 第几位开始取

40. * @return

41. */

42. public static short getShort(byte[] b, int index) {

43. return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));

44. }

45.

46. /**

47. * 转换int为byte数组

48. *

49. * @param bb

50. * @param x

51. * @param index

52. */

53. public static void putInt(byte[] bb, int x, int index) {

54. bb[index + 3] = (byte) (x >> 24);

55. bb[index + 2] = (byte) (x >> 16);

56. bb[index + 1] = (byte) (x >> 8);

57. bb[index + 0] = (byte) (x >> 0);

58. }

59.

60. /**

61. * 通过byte数组取到int

62. *

63. * @param bb

64. * @param index

65. * 第几位开始

66. * @return

67. */

68. public static int getInt(byte[] bb, int index) {

69. return (int) ((((bb[index + 3] & 0xff) << 24)

70. | ((bb[index + 2] & 0xff) << 16)

71. | ((bb[index + 1] & 0xff) << 8) | ((bb[index + 0] & 0xff) << 0)));

72. }

73.

74. /**

75. * 转换long型为byte数组

76. *

77. * @param bb

78. * @param x

79. * @param index

80. */

81. public static void putLong(byte[] bb, long x, int index) {

82. bb[index + 7] = (byte) (x >> 56);

83. bb[index + 6] = (byte) (x >> 48);

84. bb[index + 5] = (byte) (x >> 40);

85. bb[index + 4] = (byte) (x >> 32);

86. bb[index + 3] = (byte) (x >> 24);

87. bb[index + 2] = (byte) (x >> 16);

88. bb[index + 1] = (byte) (x >> 8);

89. bb[index + 0] = (byte) (x >> 0);

90. }

91.

92. /**

93. * 通过byte数组取到long

94. *

95. * @param bb

96. * @param index

97. * @return

98. */

99. public static long getLong(byte[] bb, int index) {

100. return ((((long) bb[index + 7] & 0xff) << 56)

101. | (((long) bb[index + 6] & 0xff) << 48)

102. | (((long) bb[index + 5] & 0xff) << 40)

103. | (((long) bb[index + 4] & 0xff) << 32)

104. | (((long) bb[index + 3] & 0xff) << 24)

105. | (((long) bb[index + 2] & 0xff) << 16)

106. | (((long) bb[index + 1] & 0xff) << 8) | (((long) bb[index + 0] & 0xff) << 0));

107. }

108.

109. /**

110. * 字符到字节转换

111. *

112. * @param ch

113. * @return

114. */

115. public static void putChar(byte[] bb, char ch, int index) {

116. int temp = (int) ch;

117. // byte[] b = new byte[2];

118. for (int i = 0; i < 2; i ++ ) {

119. bb[index + i] = new Integer(temp & 0xff).byteValue(); // 将最高位保存在最低位

120. temp = temp >> 8; // 向右移8位

121. }

122. }

123.

124. /**

125. * 字节到字符转换

126. *

127. * @param b

128. * @return

129. */

130. public static char getChar(byte[] b, int index) {

131. int s = 0;

132. if (b[index + 1] > 0)

133. s += b[index + 1];

134. else

135. s += 256 + b[index + 0];

136. s *= 256;

137. if (b[index + 0] > 0)

138. s += b[index + 1];

139. else

140. s += 256 + b[index + 0];

141. char ch = (char) s;

142. return ch;

143. }

144.

145. /**

146. * float转换byte

147. *

148. * @param bb

149. * @param x

150. * @param index

151. */

152. public static void putFloat(byte[] bb, float x, int index) {

153. // byte[] b = new byte[4];

154. int l = Float.floatToIntBits(x);

155. for (int i = 0; i < 4; i++) {

156. bb[index + i] = new Integer(l).byteValue();

157. l = l >> 8;

158. }

159. }

160.

161. /**

162. * 通过byte数组取得float

163. *

164. * @param bb

165. * @param index

166. * @return

167. */

168. public static float getFloat(byte[] b, int index) {

169. int l;

170. l = b[index + 0];

171. l &= 0xff;

172. l |= ((long) b[index + 1] << 8);

173. l &= 0xffff;

174. l |= ((long) b[index + 2] << 16);

175. l &= 0xffffff;

176. l |= ((long) b[index + 3] << 24);

177. return Float.intBitsToFloat(l);

178. }

179.

180. /**

181. * double转换byte

182. *

183. * @param bb

184. * @param x

185. * @param index

186. */

187. public static void putDouble(byte[] bb, double x, int index) {

188. // byte[] b = new byte[8];

189. long l = Double.doubleToLongBits(x);

190. for (int i = 0; i < 4; i++) {

191. bb[index + i] = new Long(l).byteValue();

192. l = l >> 8;

193. }

194. }

195.

196. /**

197. * 通过byte数组取得float

198. *

199. * @param bb

200. * @param index

201. * @return

202. */

203. public static double getDouble(byte[] b, int index) {

204. long l;

205. l = b[0];

206. l &= 0xff;

207. l |= ((long) b[1] << 8);

208. l &= 0xffff;

209. l |= ((long) b[2] << 16);

210. l &= 0xffffff;

211. l |= ((long) b[3] << 24);

212. l &= 0xffffffffl;

213. l |= ((long) b[4] << 32);

214. l &= 0xffffffffffl;

215. l |= ((long) b[5] << 40);

216. l &= 0xffffffffffffl;

217. l |= ((long) b[6] << 48);

218. l &= 0xffffffffffffffl;

219. l |= ((long) b[7] << 56);

220. return Double.longBitsToDouble(l);

221. }

222.}

在Java中，不存在Unsigned无符号数据类型，但可以轻而易举的完成Unsigned转换。

方案一：如果在Java中进行流(Stream)数据处理，可以用DataInputStream类对Stream中的数据以Unsigned读取。

Java在这方面提供了支持，可以用java.io.DataInputStream类对象来完成对流内数据的Unsigned读取，该类提供了如下方法：

（1）int readUnsignedByte() //从流中读取一个0~255(0xFF)的单字节数据，并以int数据类型的数据返回。返回的数据相当于C/C++语言中所谓的“BYTE”。

（2）int readUnsignedShort() //从流中读取一个0~65535(0xFFFF)的双字节数据，并以int数据类型的数据返回。返回的数据相当于C/C++语言中所谓的“WORD”，并且是以“低地址低字节”的方式返回的，所以程序员不需要额外的转换。

方案二：利用Java位运算符，完成Unsigned转换。

正常情况下，Java提供的数据类型是有符号signed类型的，可以通过位运算的方式得到它们相对应的无符号值，参见几个方法中的代码：

public int getUnsignedByte (byte data){ //将data字节型数据转换为0~255 (0xFF 即BYTE)。

return data&0x0FF;

}

public int getUnsignedByte (short data){ //将data字节型数据转换为0~65535 (0xFFFF 即 WORD)。

return data&0x0FFFF;

}

public long getUnsignedIntt (int data){ //将int数据转换为0~4294967295 (0xFFFFFFFF即DWORD)。

return data&0x0FFFFFFFFl;

}

灵活的运用这些技法，根本不存“二进制在Java中得不到全面支持”的论断！

JAVA中int、String的类型转换

int -> String

int i=12345;

String s="";

第一种方法：s=i+"";

第二种方法：s=String.valueOf(i);

这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？

String -> int

s="12345";

int i;

第一种方法：i=Integer.parseInt(s);

第二种方法：i=Integer.valueOf(s).intValue();

这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？

以下是答案：

第一种方法：s=i+""; //会产生两个String对象 第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象 第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常 第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象

--------------------------------------------------------------------
1如何将字串 String 转换成整数 int?

A. 有两个方法:

1). int i = Integer.parseInt([String]); 或

i = Integer.parseInt([String],[int radix]);

2). int i = Integer.valueOf(my_str).intValue();

注: 字串转成 Double, Float, Long 的方法大同小异.

2 如何将整数 int 转换成字串 String ?

A. 有叁种方法:

1.) String s = String.valueOf(i);

2.) String s = Integer.toString(i);

3.) String s = "" + i;

注: Double, Float, Long 转成字串的方法大同小异.

JAVA数据类型转换

这是一个例子,说的是JAVA中数据数型的转换.供大家学习

package shenmixiaozhu;

import java.sql.Date;

public class TypeChange {

public TypeChange() {

}

//change the string type to the int type

public static int stringToInt(String intstr)

{

Integer integer;

integer = Integer.valueOf(intstr);

return integer.intValue();

}

//change int type to the string type

public static String intToString(int value)

{

Integer integer = new Integer(value);

return integer.toString();

}

//change the string type to the float type

public static float stringToFloat(String floatstr)

{

Float floatee;

floatee = Float.valueOf(floatstr);

return floatee.floatValue();

}

//change the float type to the string type

public static String floatToString(float value)

{

Float floatee = new Float(value);

return floatee.toString();

}

//change the string type to the sqlDate type

public static java.sql.Date stringToDate(String dateStr)

{

return java.sql.Date.valueOf(dateStr);

}

//change the sqlDate type to the string type

public static String dateToString(java.sql.Date datee)

{

return datee.toString();

}

public static void main(String[] args)

{

java.sql.Date day ;

day = TypeChange.stringToDate("2003-11-3");

String strday = TypeChange.dateToString(day);

System.out.println(strday);

}

}

JAVA中常用数据类型转换函数

虽然都能在JAVA API中找到，整理一下做个备份。

java中byte转换int时为何与0xff进行与运算

/article/1400307.html

在剖析该问题前请看如下代码

例一：

[java] view
plain copy

/**

* 从byte数组开始位置取4位得到一个int

* @paramababyte数组

* @return返回int值

*/

public staticint getIntFromByte(byte[] ba)

{

int sum = 0;

for (int i = 0; i < 4; i++)

{

int temp = ((int) ba[i]) & 0xff;

temp <<= i * 8;

sum = temp + sum;

}

return sum;

}

public static String bytes2HexString(byte[] b) {

String ret = "";

for (int i = 0; i < b.length; i++) {

String hex = Integer.toHexString(b[i] & 0xFF);

if (hex.length() == 1) {

hex = '0' + hex;

}

ret += hex.toUpperCase();

}

return ret;

}

上面是将byte[]转化十六进制的字符串,注意这里b[ i ]& 0xFF将一个byte和 0xFF进行了与运算,然后使用Integer.toHexString取得了十六进制字符串,可以看出

b[i]& 0xFF运算后得出的仍然是个int,那么为何要和 0xFF进行与运算呢?直接 Integer.toHexString(b[ i ]);,将byte强转为int不行吗?答案是不行的.

其原因在于:

1.byte的大小为8bits而int的大小为32bits，java的二进制采用的是补码形式。

二进制原码表示法

原码表示法是机器数的一种简单的表示法。其符号位用0表示正号，用：表示负号，数值一般用二进制形式表示。设有一数为x，则原码表示可记作［x］原。

例如，X1= ＋1010110

X2= -1001010

其原码记作：

［X1］原=[＋1010110]原=01010110

［X2］原=[－1001010]原=11001010

byte是一个字节保存的，有8个位，8位的第一个位是符号位，也就是说0000 0001代表的是数1 ，1000 0001代表的就是-1 所以正数最大位0111 1111，也就是数字127 负数最大为1111 1111，也就是数字-127

在原码表示法中，对0有两种表示形式：

［+0］原=00000000

[－0] 原=10000000

二进制补码表示法

java中采用的是补码的形式，下面介绍下什么是补码和反码；

1、反码：

一个数如果是正，则它的反码与原码相同；

一个数如果是负，则符号位为1，其余各位是对原码取反；

机器数的反码可由原码得到。如果机器数是正数，则该机器数的反码与原码一样；如果机器数是负数，则该机器数的反码是对它的原码（符号位除外）各位取反而得到的。设有一数X，则X的反码表示记作［X］反。

例如：X1= ＋1010110

X2= 一1001010

［X1］原=01010110

[X1]反=［X1］原=01010110

[X2]原=11001010

[X2]反=10110101

2、补码：

机器数的补码可由原码得到。如果机器数是正数，则该机器数的补码与原码一样；如果机器数是负数，则该机器数的补码是对它的原码（除符号位外）各位取反，并在未位加1而得到的。设有一数X，则X的补码表示记作［X］补。

⑴一个数为正，则它的原码、反码、补码相同

⑵一个数为负，刚符号位为1，其余各位是对原码取反，然后整个数加1

- 1的原码为 10000001

- 1的反码为 11111110

+ 1

- 1的补码为 11111111

0的原码为 00000000

0的反码为 11111111（正零和负零的反码相同）

+1

0的补码为 100000000（舍掉打头的1，正零和负零的补码相同）

利用溢出，我们可以将减法变成加法

对于十进制数，从9得到5可用减法：

9－4＝5 因为4+6＝10，我们可以将6作为4的补数

改写为加法：

9+(10-4)= 9+6＝15（去掉高位1，也就是减10）得到5.

对于十六进制数，从c到5可用减法：

c－7＝5 因为7+9＝16 将9作为7的补数

改写为加法：

c+(16-7)=c+9＝15（去掉高位1，也就是减16）得到5.

在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为（100000000），进位1被丢弃。

Integer.toHexString的参数是int，如果不进行0xff，那么当一个byte会转换成int时，由于int是32位，而byte只有8位,这时会进行填充，如果byte的最高位是0的话，int的前面填充0，例如01000001转化成int就变为00000000000000000000000001000001

如果byte的最高位是1的话，int的前面填充1例如11111111的十进制数为-1转换为int时变为11111111111111111111111111111111好多1啊，呵呵！即0xffffffff但是这个数是不对的，这种补位就会造成误差。和0xff相与后，高24比特就会被清0了，结果就对了。