现在的位置: 首页 > 综合 > 正文

Java类型转换(int – byte[],float – byte[]) java中byte转换int时为何与0xff进行与运算

2013年06月17日 ⁄ 综合 ⁄ 共 10061字 ⁄ 字号 评论关闭

有符号字节转成无符号字节 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的转换

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

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

 

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进行与运算

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了,结果就对了。

抱歉!评论已关闭.