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

柔光的暖阳◎ 2022-06-03 06:22 542阅读 0赞

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

  1. int unsignedByte = signedByte >= 0 ? signedByte :256 + signedByte;
  2.         int byteValue;
  3.         int temp = intValue % 256;
  4.        if ( intValue < 0) {
  5.                byteValue = temp < -128 ?256 + temp : temp;
  6.         }
  7.         else {
  8.                byteValue = temp > 127 ? temp -256 : temp;
  9.         }

float -> byte[]

先用 Float.floatToIntBits(f)转换成int
再通过如下方法转成byte []

int -> byte[] 

  1. /**
  2.   * 将int类型的数据转换为byte数组
  3.   * 原理：将int数据中的四个byte取出，分别存储
  4.   * @param n int数据
  5.   * @return 生成的byte数组
  6.   */
  7. public static byte[] intToBytes2(int n){
  8.     byte[] b = new byte[4];
  9.     for(int i = 0;i < 4;i++){
  10.         b[i] = (byte)(n >> (24 - i * 8)); 
  11.     }
  12.     return b;
  13. }
  15. byte[] -> int
  16. /**
  17.   * 将byte数组转换为int数据
  18.   * @param b 字节数组
  19.   * @return 生成的int数据
  20.   */
  21.   public static int byteToInt2(byte[] b){
  22.       return (((int)b[0]) << 24) + (((int)b[1]) << 16) + (((int)b[2]) << 8) + b[3];
  23.   }
  24. }

byte[] -> float

  1. public static float getFloat(byte[] b) {
  2.         // 4 bytes
  3.         int accum = 0;
  4.         for ( int shiftBy = 0; shiftBy < 4; shiftBy++ ) {
  5.                 accum |= (b[shiftBy] & 0xff) << shiftBy * 8;
  6.         }
  7.         return Float.intBitsToFloat(accum);
  8.     }

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

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

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

  1. 1.package com.util;  
  2. 2.  
  3. 3./** 
  4. 4. *  
  5. 5. * <ul> 
  6. 6. * <li>文件名称: com.born.util.ByteUtil.java</li> 
  7. 7. * <li>文件描述: byte转换工具</li> 
  8. 8. * <li>版权所有: 版权所有(C)2001-2006</li> 
  9. 9. * <li>公 司: bran</li> 
  10. 10. * <li>内容摘要:</li> 
  11. 11. * <li>其他说明:</li> 
  12. 12. * <li>完成日期：2011-7-18</li> 
  13. 13. * <li>修改记录0：无</li> 
  14. 14. * </ul> 
  15. 15. *  
  16. 16. * @version 1.0 
  17. 17. * @author 许力多 
  18. 18. */  
  19. 19.public class ByteUtil {  
  20. 20.    /** 
  21. 21.     * 转换short为byte 
  22. 22.     *  
  23. 23.     * @param b 
  24. 24.     * @param s 
  25. 25.     *            需要转换的short 
  26. 26.     * @param index 
  27. 27. 
  28. 28.     */  
  29. 29.    public static void putShort(byte b[], short s, int index) {  
  30. 30.        b[index + 1] = (byte) (s >> 8);  
  31. 31.        b[index + 0] = (byte) (s >> 0);  
  32. 32.    }  
  33. 33.  
  34. 34.    /** 
  35. 35.     * 通过byte数组取到short 
  36. 36.     *  
  37. 37.     * @param b 
  38. 38.     * @param index 
  39. 39.     *            第几位开始取 
  40. 40.     * @return 
  41. 41.     */  
  42. 42.    public static short getShort(byte[] b, int index) {  
  43. 43.        return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));  
  44. 44.    }  
  45. 45.  
  46. 46.    /** 
  47. 47.     * 转换int为byte数组 
  48. 48.     *  
  49. 49.     * @param bb 
  50. 50.     * @param x 
  51. 51.     * @param index 
  52. 52.     */  
  53. 53.    public static void putInt(byte[] bb, int x, int index) {  
  54. 54.        bb[index + 3] = (byte) (x >> 24);  
  55. 55.        bb[index + 2] = (byte) (x >> 16);  
  56. 56.        bb[index + 1] = (byte) (x >> 8);  
  57. 57.        bb[index + 0] = (byte) (x >> 0);  
  58. 58.    }  
  59. 59.  
  60. 60.    /** 
  61. 61.     * 通过byte数组取到int 
  62. 62.     *  
  63. 63.     * @param bb 
  64. 64.     * @param index 
  65. 65.     *            第几位开始 
  66. 66.     * @return 
  67. 67.     */  
  68. 68.    public static int getInt(byte[] bb, int index) {  
  69. 69.        return (int) ((((bb[index + 3] & 0xff) << 24)  
  70. 70.                | ((bb[index + 2] & 0xff) << 16)  
  71. 71.                | ((bb[index + 1] & 0xff) << 8) | ((bb[index + 0] & 0xff) << 0)));  
  72. 72.    }  
  73. 73.  
  74. 74.    /** 
  75. 75.     * 转换long型为byte数组 
  76. 76.     *  
  77. 77.     * @param bb 
  78. 78.     * @param x 
  79. 79.     * @param index 
  80. 80.     */  
  81. 81.    public static void putLong(byte[] bb, long x, int index) {  
  82. 82.        bb[index + 7] = (byte) (x >> 56);  
  83. 83.        bb[index + 6] = (byte) (x >> 48);  
  84. 84.        bb[index + 5] = (byte) (x >> 40);  
  85. 85.        bb[index + 4] = (byte) (x >> 32);  
  86. 86.        bb[index + 3] = (byte) (x >> 24);  
  87. 87.        bb[index + 2] = (byte) (x >> 16);  
  88. 88.        bb[index + 1] = (byte) (x >> 8);  
  89. 89.        bb[index + 0] = (byte) (x >> 0);  
  90. 90.    }  
  91. 91.  
  92. 92.    /** 
  93. 93.     * 通过byte数组取到long 
  94. 94.     *  
  95. 95.     * @param bb 
  96. 96.     * @param index 
  97. 97.     * @return 
  98. 98.     */  
  99. 99.    public static long getLong(byte[] bb, int index) {  
  100. 100.        return ((((long) bb[index + 7] & 0xff) << 56)  
  101. 101.                | (((long) bb[index + 6] & 0xff) << 48)  
  102. 102.                | (((long) bb[index + 5] & 0xff) << 40)  
  103. 103.                | (((long) bb[index + 4] & 0xff) << 32)  
  104. 104.                | (((long) bb[index + 3] & 0xff) << 24)  
  105. 105.                | (((long) bb[index + 2] & 0xff) << 16)  
  106. 106.                | (((long) bb[index + 1] & 0xff) << 8) | (((long) bb[index + 0] & 0xff) << 0));  
  107. 107.    }  
  108. 108.  
  109. 109.    /** 
  110. 110.     * 字符到字节转换 
  111. 111.     *  
  112. 112.     * @param ch 
  113. 113.     * @return 
  114. 114.     */  
  115. 115.    public static void putChar(byte[] bb, char ch, int index) {  
  116. 116.        int temp = (int) ch;  
  117. 117.        // byte[] b = new byte[2];  
  118. 118.        for (int i = 0; i < 2; i ++ ) {  
  119. 119.            bb[index + i] = new Integer(temp & 0xff).byteValue(); // 将最高位保存在最低位  
  120. 120.            temp = temp >> 8; // 向右移8位  
  121. 121.        }  
  122. 122.    }  
  123. 123.  
  124. 124.    /** 
  125. 125.     * 字节到字符转换 
  126. 126.     *  
  127. 127.     * @param b 
  128. 128.     * @return 
  129. 129.     */  
  130. 130.    public static char getChar(byte[] b, int index) {  
  131. 131.        int s = 0;  
  132. 132.        if (b[index + 1] > 0)  
  133. 133.            s += b[index + 1];  
  134. 134.        else  
  135. 135.            s += 256 + b[index + 0];  
  136. 136.        s *= 256;  
  137. 137.        if (b[index + 0] > 0)  
  138. 138.            s += b[index + 1];  
  139. 139.        else  
  140. 140.            s += 256 + b[index + 0];  
  141. 141.        char ch = (char) s;  
  142. 142.        return ch;  
  143. 143.    }  
  144. 144.  
  145. 145.    /** 
  146. 146.     * float转换byte 
  147. 147.     *  
  148. 148.     * @param bb 
  149. 149.     * @param x 
  150. 150.     * @param index 
  151. 151.     */  
  152. 152.    public static void putFloat(byte[] bb, float x, int index) {  
  153. 153.        // byte[] b = new byte[4];  
  154. 154.        int l = Float.floatToIntBits(x);  
  155. 155.        for (int i = 0; i < 4; i++) {  
  156. 156.            bb[index + i] = new Integer(l).byteValue();  
  157. 157.            l = l >> 8;  
  158. 158.        }  
  159. 159.    }  
  160. 160.  
  161. 161.    /** 
  162. 162.     * 通过byte数组取得float 
  163. 163.     *  
  164. 164.     * @param bb 
  165. 165.     * @param index 
  166. 166.     * @return 
  167. 167.     */  
  168. 168.    public static float getFloat(byte[] b, int index) {  
  169. 169.        int l;  
  170. 170.        l = b[index + 0];  
  171. 171.        l &= 0xff;  
  172. 172.        l |= ((long) b[index + 1] << 8);  
  173. 173.        l &= 0xffff;  
  174. 174.        l |= ((long) b[index + 2] << 16);  
  175. 175.        l &= 0xffffff;  
  176. 176.        l |= ((long) b[index + 3] << 24);  
  177. 177.        return Float.intBitsToFloat(l);  
  178. 178.    }  
  179. 179.  
  180. 180.    /** 
  181. 181.     * double转换byte 
  182. 182.     *  
  183. 183.     * @param bb 
  184. 184.     * @param x 
  185. 185.     * @param index 
  186. 186.     */  
  187. 187.    public static void putDouble(byte[] bb, double x, int index) {  
  188. 188.        // byte[] b = new byte[8];  
  189. 189.        long l = Double.doubleToLongBits(x);  
  190. 190.        for (int i = 0; i < 4; i++) {  
  191. 191.            bb[index + i] = new Long(l).byteValue();  
  192. 192.            l = l >> 8;  
  193. 193.        }  
  194. 194.    }  
  195. 195.  
  196. 196.    /** 
  197. 197.     * 通过byte数组取得float 
  198. 198.     *  
  199. 199.     * @param bb 
  200. 200.     * @param index 
  201. 201.     * @return 
  202. 202.     */  
  203. 203.    public static double getDouble(byte[] b, int index) {  
  204. 204.        long l;  
  205. 205.        l = b[0];  
  206. 206.        l &= 0xff;  
  207. 207.        l |= ((long) b[1] << 8);  
  208. 208.        l &= 0xffff;  
  209. 209.        l |= ((long) b[2] << 16);  
  210. 210.        l &= 0xffffff;  
  211. 211.        l |= ((long) b[3] << 24);  
  212. 212.        l &= 0xffffffffl;  
  213. 213.        l |= ((long) b[4] << 32);  
  214. 214.        l &= 0xffffffffffl;  
  215. 215.        l |= ((long) b[5] << 40);  
  216. 216.        l &= 0xffffffffffffl;  
  217. 217.        l |= ((long) b[6] << 48);  
  218. 218.        l &= 0xffffffffffffffl;  
  219. 219.        l |= ((long) b[7] << 56);  
  220. 220.        return Double.longBitsToDouble(l);  
  221. 221.    }  
  222. 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进行与运算

http://blog.csdn.net/xiaojianpitt/article/details/2728756

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

例一：

  1. /**
  2.          * 从byte数组开始位置取4位得到一个int
  3.          * @paramababyte数组
  4.          * @return返回int值
  5.          */
  6.         public staticint getIntFromByte(byte[] ba)
  7.         {
  8.             int sum = 0;
  9.             for (int i = 0; i < 4; i++)
  10.             {
  11.                 int temp = ((int) ba[i]) & 0xff;
  12.                 temp <<= i * 8;
  13.                 sum = temp + sum;
  14.             }
  16.             return sum;
  17.         }
  19.         public static String bytes2HexString(byte[] b) {
  20.             String ret = "";
  21.             for (int i = 0; i < b.length; i++) {
  22.                 String hex = Integer.toHexString(b[i] & 0xFF);
  23.                 if (hex.length() == 1) {
  24.                     hex = '0' + hex;
  25.                 }
  26.                 ret += hex.toUpperCase();
  27.             }
  28.             return ret;
  29.         }

上面是将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了，结果就对了。

发表评论

表情：
评论列表 （有 0 条评论，542人围观）

还没有评论，来说两句吧...

相关阅读