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

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

### [有符号字节转成无符号字节 java int 转成 byte][java int _ byte] ###

int unsignedByte = signedByte >= 0 ? signedByte :256 + signedByte;
            int byteValue;
            int temp = intValue % 256;
           if ( intValue < 0) {
                   byteValue = temp < -128 ?256 + temp : temp;
            }
            else {
                   byteValue = temp > 127 ? temp -256 : temp;
            }

float -> byte\[\]

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

int -> byte\[\]

/**
      * 将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

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的转换][java_int_char_long_float_double_byte] #

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

[http://xuliduo.iteye.com/blog/1126957][java_int_char_long_float_double_byte]

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();  
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？

**以下是答案：**

<table style="border-right-width:1px; border-top-width:1px; border-bottom-width:1px; border-left-width:1px"> 
 <tbody> 
  <tr> 
   <td style="word-wrap:break-word; height:25px"> <p><span style="color:#3131df">第一种方法：s=i+""; //会产生两个String对象<br> 第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象</span></p> <p><span style="color:#3131df">第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常<br> 第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象</span></p> </td> 
  </tr> 
 </tbody> 
</table>

\--------------------------------------------------------------------

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进行与运算][java_byte_int_0xff] #

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

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

例一：

/**
    		 * 从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了，结果就对了。

[java int _ byte]: http://zgqhyh.iteye.com/blog/151129
[java_int_char_long_float_double_byte]: http://xuliduo.iteye.com/blog/1126957
[java_byte_int_0xff]: http://blog.csdn.net/xiaojianpitt/article/details/2728756