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種情況你試下估計就了解了