androidbyte转int

A. eclipse写android程序，怎么将从蓝牙模块中接受的16进制的数据转换成十进制

/* *
* Convert byte[] to hex string.我byte转换int利用Integer.toHexString(int)
*转换16进制字符串
* @param src byte[] data
* @return hex string
*/
public static String bytesToHexString(byte[] src){
StringBuilder stringBuilder = new StringBuilder("");
if (src == null || src.length <= 0) {
return null;
}
for (int i = 0; i < src.length; i++) {
int v = src[i] & 0xFF;
String hv = Integer.toHexString(v);
if (hv.length() < 2) {
stringBuilder.append(0);
}
stringBuilder.append(hv);
}
return stringBuilder.toString();
}
能byte[]转化16进制字符串希望能帮

B. java中byte[]转换成int

java中byte转换为 int有两种情况，一种是要求保持值不变，例如进行数值计算，可采用强制类型转换：int i = (int) aByte;
另一种是要求保持最低字节中各个位不变，3个高字节全部用0填充，例如进行编解码操作，
则需要采用位操作：int i = b & 0xff;

int InputStream.read()
该函数返回一个int类型，范围从0至255，如果到达流末尾，返回-1。通过ByteArrayInputStream的源码可以看到是如何从byte转到int
public synchronized int read() {
return (pos < count) ? (buf[pos++] & 0xff) : -1;
}

注意，不是自动转的，需要强制做处理。

C. byte和int的类型转化问题

因为byte相加时会默认的转换成int类型 （别问为什么了，具体实现就是这样的） 所以相加后的类型也是int类型的

D. byte[] 转为 int

四个字节= 1个int

用移位

int a = b[0]+b[1]<<8+b[2]<<16+b[3]<<24

E. 如何将 byte 转换为 IntPtr

c++.net中可使用内部指针来实现，但C#未提供内部指针，可使用如下替代方法：
设存在 byte[] bs;则
using System.IO;
...
MemoryStream 流 = new MemoryStream(bs); 流.Position = 0;
BinaryReader 读 = new BinaryReader(流);
string 数据 = 读.ReadString();//假设你把bs中的数据解释为UniCode字符串。
//short 数据 = 读.ReadInt16();//假设你把bs中的数据解释为短整数。
//int 数据 = 读.ReadInt32();//假设你把bs中的数据解释为32位整数。
...

F. 做Android蓝牙通信，byte转int求教

传输的2种方式：
1. 16 进制传输， 可以打印字符, 所有的内容都是0x00-0xFF,转化为byte的时候直接把16进制转化为byte
2. AscII 转化 new String(byte), 比如特殊字符串abc , 转化为byte的时候取字符的ASCII码，转化为byte
1. 首先理解左移、右移:
1<<1 =2 ： 1左移1位, 相当于乘2,左移多少位,乘多少个2
1： 0000 0001 1
<<1: 0000 0010 2,超出8位长度丢掉,左边补0

2>>1 = 1 : 右移, 右边补0
2: 0000 0010 2
2>>1 0000 0001 1
如何把int 转化为byte 数组
使用byteArrayOutputStream
使用左移、右移
2. 使用左右移动实现
App->Ble 小端存储：
public static byte[] int2BytesArray(int n) {
byte[] b = new byte[4];
for (int i = 0; i < 4; i++) {
b[i] = (byte) (n >> (24 - i * 8));
}
byte[] transitionByte=new byte[4];
transitionByte[3]=b[0];
transitionByte[2]=b[1];
transitionByte[1]=b[2];
transitionByte[0]=b[3];
return transitionByte;
}
比如： 00001100 00001111 00001001 00000001 ： 202311937【int】
使用小端存储： 低字节存储低字节 高字节存储高字节
i= 0 右移24个字节 00000000 00000000 00000000 00001100
转化为byte, 丢弃前3个字节， 00001100 高字节
transitionByte[3]=b[0]; 高字节存储高地址

transitionByte[2]：
i=1 右移动16 个字节 00000000 00000000 00001100 00001111
转化为byte, 丢弃前3个字节 00001111
最终：00001111
Ble->App 数据解析
byte[] sTime = new byte[4]; // 小端存储 byte[0] 存储低位

G. android中如何进行强制类型转换

Java 的自动转换

如果下列2个条件都能满足，那么将一种类型的数据赋给另外一种类型变量时，将执行自动类型转换（automatic type conversion）：

1，这2种类型是兼容的。
2，目的类型数的范围比来源类型的大。 ,
当以上2个条件都满足时，拓宽转换（widening conversion ）发生。
例如，int 型的范围比所有byte 型的合法范围大，因此不要求显式强制类型转换语句。
对于拓宽转换，数字类型，包括整数（integer ）和浮点（floating-point ）类型都是彼此兼容的，
但是，数字类型和字符类型（char）或布尔类型（bollean ）是不兼容的。字符类型（char ）和布尔类型（bollean ）也是互相不兼容的。

不兼容类型的强制转换

尽管自动类型转换是很有帮助的，但并不能满足所有的编程需要。例如，如果你需要将int 型的值赋给一个byte 型的变量，
你将怎么办？这种转换不会自动进行，因为byte 型的变化范围比int 型的要小。这种转换有时称为“缩小转换”（），
因为你肯定要将源数据类型的值变小才能适合目标数据类型。

为了完成两种不兼容类型之间的转换，你就必须进行强制类型转换。所谓强制类型转换只不过是一种显式的类型变换。它的通用格式如下：

(target-type)value

其中，目标类型（target-type ）指定了要将指定值转换成的类型。例如，下面的程序段将int 型强制转换成byte 型。
如果整数的值超出了byte 型的取值范围，它的值将会因为对byte 型值域取模（整数除以byte 得到的余数）而减少。

int a;

byte b;

// ...

b = (byte) a;

当把浮点值赋给整数类型时一种不同的类型转换发生了：截断（truncation ）。你知道整数没有小数部分。
这样，当把浮点值赋给整数类型时，它的小数部分会被舍去。例如，如果将值1.23赋给一个整数，其结果值只是1，0.23 被丢弃了。
当然，如果浮点值太大而不能适合目标整数类型，那么它的值将会因为对目标类型值域取模而减少。

H. 如何把一个byte数组的数字转换成int

这里简单记录下两种转换方式：
第一种：
1、int与byte[]之间的转换（类似的byteshort,long型）
[java]viewplain
/**
*将int数值转换为占四个字节的byte数组，本方法适用于(低位在前，高位在后)的顺序。和bytesToInt（）配套使用
*@paramvalue
*要转换的int值
*@returnbyte数组
*/
publicstaticbyte[]intToBytes(intvalue)
{
byte[]src=newbyte[4];
src[3]=(byte)((value>>24)&0xFF);
src[2]=(byte)((value>>16)&0xFF);
src[1]=(byte)((value>>8)&0xFF);
src[0]=(byte)(value&0xFF);
returnsrc;
}
/**
*将int数值转换为占四个字节的byte数组，本方法适用于(高位在前，低位在后)的顺序。和bytesToInt2（）配套使用
*/
publicstaticbyte[]intToBytes2(intvalue)
{
byte[]src=newbyte[4];
src[0]=(byte)((value>>24)&0xFF);
src[1]=(byte)((value>>16)&0xFF);
src[2]=(byte)((value>>8)&0xFF);
src[3]=(byte)(value&0xFF);
returnsrc;
}

byte[]转int
[java]viewplain
/**
*byte数组中取int数值，本方法适用于(低位在前，高位在后)的顺序，和和intToBytes（）配套使用
*
*@paramsrc
*byte数组
*@paramoffset
*从数组的第offset位开始
*@returnint数值
*/
publicstaticintbytesToInt(byte[]src,intoffset){
intvalue;
value=(int)((src[offset]&0xFF)
|((src[offset+1]&0xFF)<<8)
|((src[offset+2]&0xFF)<<16)
|((src[offset+3]&0xFF)<<24));
returnvalue;
}

/**
*byte数组中取int数值，本方法适用于(低位在后，高位在前)的顺序。和intToBytes2（）配套使用
*/
publicstaticintbytesToInt2(byte[]src,intoffset){
intvalue;
value=(int)(((src[offset]&0xFF)<<24)
|((src[offset+1]&0xFF)<<16)
|((src[offset+2]&0xFF)<<8)
|(src[offset+3]&0xFF));
returnvalue;
}

第二种：1、int与byte[]之间的转换（类似的byte
short,long型）
[java]viewplain
/**
*将int数值转换为占四个字节的byte数组，本方法适用于(低位在前，高位在后)的顺序。
*@paramvalue
*要转换的int值
*@returnbyte数组
*/
publicstaticbyte[]intToBytes(intvalue)
{
byte[]byte_src=newbyte[4];
byte_src[3]=(byte)((value&0xFF000000)>>24);
byte_src[2]=(byte)((value&0x00FF0000)>>16);
byte_src[1]=(byte)((value&0x0000FF00)>>8);
byte_src[0]=(byte)((value&0x000000FF));
returnbyte_src;
}

byte[]转int
[java]viewplain
/**
*byte数组中取int数值，本方法适用于(低位在前，高位在后)的顺序。
*
*@paramary
*byte数组
*@paramoffset
*从数组的第offset位开始
*@returnint数值
*/
publicstaticintbytesToInt(byte[]ary,intoffset){
intvalue;
value=(int)((ary[offset]&0xFF)
|((ary[offset+1]<<8)&0xFF00)
|((ary[offset+2]<<16)&0xFF0000)
|((ary[offset+3]<<24)&0xFF000000));
returnvalue;
}

I. 关于 byte 转化为 int 的疑问

bytes[3]<<24 这样子是你说的那样
我想是因为函数是返回 int型
等于先把每个都强制转化成int型 再 “|”运算
我试验了下 是与 "|" 有关

char a = 10;
char b = 20;

int c;

c = a<<10 | b<<10 ;
或者 c = a<<10 + b<<10 2种情况你试下估计就了解了