編輯：關於Android編程
想起前段時間的物聯網的外包開發，經常遇到通過wifi接受的數據，要通過轉換成十六進制字符串，或者最後又是十進制數據。都是根據雙方的協議來開發的。那麼我發送過去的數據也需要，經過特殊轉換成byte字節發過去，硬件那邊收到不至於亂碼的數據。
DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
byte readBuffer[] = new byte[64];
int count = 0;
try {
count = dis.read(readBuffer);
} catch (IOException e) {
continue;
}
readBuffer收到數據是這樣的：104, 56, 56, 104, 0, 114, 120, 85, 52, 18, 67, 35, 1, 7, 0, 0, 0, 0, 12, 19, 120, 86, 52, 18, 12, 59, 120, 52, 18, 12, 38, 120, 86, 52, 18, 11, 89, 69, 35, 0, 2, -3, 23, 0, 0, 22
那麼要根據這些數據轉換成十六進制的字符串，如果你直接轉換成String字符串那肯定亂碼了。因為硬件調試發給android這邊是十六進制數據。
readBuffer字節數組轉後數據十六進制是這樣的：68 , 38 , 38 , 68 , 00 , 72 , 78 , 55 , 34 , 12 , 43 , 23 , 01 , 07 , 00 , 00 , 00 , 00 , 0C , 13 , 78 , 56 , 34 , 12 , 0C , 3B , 78 , 34 , 12 , 0C , 26 , 78 , 56 , 34 , 12 , 0B , 59 , 45 , 23 , 00 , 02 , FD , 17 , 00 , 00 , 16
可以看出跟硬件發的是不是一樣了。這裡面不是十六進制Y，CS就用00填充了。
當然這些都是根據雙方收發數據來解析，處理的。
private String mstrRestartSend = "FE FE 68 04 04 68 53 FD 50 00 A0 16";
private byte[] mRestart = null;
mRestart = StringUtil.HexCommandtoByte(mstrRestartSend.getBytes());
public class StringUtil {
// 十六進制的字符串轉換成byte數組
public static byte[] HexCommandtoByte(byte[] data) {
if (data == null) {
return null;
}
int nLength = data.length;
String strTemString = new String(data, 0, nLength);
String[] strings = strTemString.split(" ");
nLength = strings.length;
data = new byte[nLength];
for (int i = 0; i < nLength; i++) {
if (strings[i].length() != 2) {
data[i] = 00;
continue;
}
try {
data[i] = (byte)Integer.parseInt(strings[i], 16);
} catch (Exception e) {
data[i] = 00;
continue;
}
}
return data;
}
}
那麼這樣發過去就不會錯誤或者亂碼。示例圖：
public class DigitalTrans {
/**
* 數字字符串轉ASCII碼字符串
*
* @param String
* 字符串
* @return ASCII字符串
*/
public static String StringToAsciiString(String content) {
String result = "";
int max = content.length();
for (int i = 0; i < max; i++) {
char c = content.charAt(i);
String b = Integer.toHexString(c);
result = result + b;
}
return result;
}
/**
* 十六進制轉字符串
*
* @param hexString
* 十六進制字符串
* @param encodeType
* 編碼類型4：Unicode，2：普通編碼
* @return 字符串
*/
public static String hexStringToString(String hexString, int encodeType) {
String result = "";
int max = hexString.length() / encodeType;
for (int i = 0; i < max; i++) {
char c = (char) DigitalTrans.hexStringToAlgorism(hexString
.substring(i * encodeType, (i + 1) * encodeType));
result += c;
}
return result;
}
/**
* 十六進制字符串裝十進制
*
* @param hex
* 十六進制字符串
* @return 十進制數值
*/
public static int hexStringToAlgorism(String hex) {
hex = hex.toUpperCase();
int max = hex.length();
int result = 0;
for (int i = max; i > 0; i--) {
char c = hex.charAt(i - 1);
int algorism = 0;
if (c >= '0' && c <= '9') {
algorism = c - '0';
} else {
algorism = c - 55;
}
result += Math.pow(16, max - i) * algorism;
}
return result;
}
/**
* 十六轉二進制
*
* @param hex
* 十六進制字符串
* @return 二進制字符串
*/
public static String hexStringToBinary(String hex) {
hex = hex.toUpperCase();
String result = "";
int max = hex.length();
for (int i = 0; i < max; i++) {
char c = hex.charAt(i);
switch (c) {
case '0':
result += "0000";
break;
case '1':
result += "0001";
break;
case '2':
result += "0010";
break;
case '3':
result += "0011";
break;
case '4':
result += "0100";
break;
case '5':
result += "0101";
break;
case '6':
result += "0110";
break;
case '7':
result += "0111";
break;
case '8':
result += "1000";
break;
case '9':
result += "1001";
break;
case 'A':
result += "1010";
break;
case 'B':
result += "1011";
break;
case 'C':
result += "1100";
break;
case 'D':
result += "1101";
break;
case 'E':
result += "1110";
break;
case 'F':
result += "1111";
break;
}
}
return result;
}
/**
* ASCII碼字符串轉數字字符串
*
* @param String
* ASCII字符串
* @return 字符串
*/
public static String AsciiStringToString(String content) {
String result = "";
int length = content.length() / 2;
for (int i = 0; i < length; i++) {
String c = content.substring(i * 2, i * 2 + 2);
int a = hexStringToAlgorism(c);
char b = (char) a;
String d = String.valueOf(b);
result += d;
}
return result;
}
/**
* 將十進制轉換為指定長度的十六進制字符串
*
* @param algorism
* int 十進制數字
* @param maxLength
* int 轉換後的十六進制字符串長度
* @return String 轉換後的十六進制字符串
*/
public static String algorismToHEXString(int algorism, int maxLength) {
String result = "";
result = Integer.toHexString(algorism);
if (result.length() % 2 == 1) {
result = "0" + result;
}
return patchHexString(result.toUpperCase(), maxLength);
}
/**
* 字節數組轉為普通字符串（ASCII對應的字符）
*
* @param bytearray
* byte[]
* @return String
*/
public static String bytetoString(byte[] bytearray) {
String result = "";
char temp;
int length = bytearray.length;
for (int i = 0; i < length; i++) {
temp = (char) bytearray[i];
result += temp;
}
return result;
}
/**
* 二進制字符串轉十進制
*
* @param binary
* 二進制字符串
* @return 十進制數值
*/
public static int binaryToAlgorism(String binary) {
int max = binary.length();
int result = 0;
for (int i = max; i > 0; i--) {
char c = binary.charAt(i - 1);
int algorism = c - '0';
result += Math.pow(2, max - i) * algorism;
}
return result;
}
/**
* 十進制轉換為十六進制字符串
*
* @param algorism
* int 十進制的數字
* @return String 對應的十六進制字符串
*/
public static String algorismToHEXString(int algorism) {
String result = "";
result = Integer.toHexString(algorism);
if (result.length() % 2 == 1) {
result = "0" + result;
}
result = result.toUpperCase();
return result;
}
/**
* HEX字符串前補0，主要用於長度位數不足。
*
* @param str
* String 需要補充長度的十六進制字符串
* @param maxLength
* int 補充後十六進制字符串的長度
* @return 補充結果
*/
static public String patchHexString(String str, int maxLength) {
String temp = "";
for (int i = 0; i < maxLength - str.length(); i++) {
temp = "0" + temp;
}
str = (temp + str).substring(0, maxLength);
return str;
}
/**
* 將一個字符串轉換為int
*
* @param s
* String 要轉換的字符串
* @param defaultInt
* int 如果出現異常,默認返回的數字
* @param radix
* int 要轉換的字符串是什麼進制的,如16 8 10.
* @return int 轉換後的數字
*/
public static int parseToInt(String s, int defaultInt, int radix) {
int i = 0;
try {
i = Integer.parseInt(s, radix);
} catch (NumberFormatException ex) {
i = defaultInt;
}
return i;
}
/**
* 將一個十進制形式的數字字符串轉換為int
*
* @param s
* String 要轉換的字符串
* @param defaultInt
* int 如果出現異常,默認返回的數字
* @return int 轉換後的數字
*/
public static int parseToInt(String s, int defaultInt) {
int i = 0;
try {
i = Integer.parseInt(s);
} catch (NumberFormatException ex) {
i = defaultInt;
}
return i;
}
/**
* 十六進制字符串轉為Byte數組,每兩個十六進制字符轉為一個Byte
*
* @param hex
* 十六進制字符串
* @return byte 轉換結果
*/
public static byte[] hexStringToByte(String hex) {
int max = hex.length() / 2;
byte[] bytes = new byte[max];
String binarys = DigitalTrans.hexStringToBinary(hex);
for (int i = 0; i < max; i++) {
bytes[i] = (byte) DigitalTrans.binaryToAlgorism(binarys.substring(
i * 8 + 1, (i + 1) * 8));
if (binarys.charAt(8 * i) == '1') {
bytes[i] = (byte) (0 - bytes[i]);
}
}
return bytes;
}
/**
* 十六進制串轉化為byte數組
*
* @return the array of byte
*/
public static final byte[] hex2byte(String hex)
throws IllegalArgumentException {
if (hex.length() % 2 != 0) {
throw new IllegalArgumentException();
}
char[] arr = hex.toCharArray();
byte[] b = new byte[hex.length() / 2];
for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
String swap = "" + arr[i++] + arr[i];
int byteint = Integer.parseInt(swap, 16) & 0xFF;
b[j] = new Integer(byteint).byteValue();
}
return b;
}
/**
* 字節數組轉換為十六進制字符串
*
* @param b
* byte[] 需要轉換的字節數組
* @return String 十六進制字符串
*/
public static final String byte2hex(byte b[]) {
if (b == null) {
throw new IllegalArgumentException(
"Argument b ( byte array ) is null! ");
}
String hs = "";
String stmp = "";
for (int n = 0; n < b.length; n++) {
stmp = Integer.toHexString(b[n] & 0xff);
if (stmp.length() == 1) {
hs = hs + "0" + stmp;
} else {
hs = hs + stmp;
}
}
return hs.toUpperCase();
}
}
Android自定義Spinner下拉列表（使用ArrayAdapter和自定義Adapter實現）
今天學習了Spinner組件的使用，非常好用的一款組件，相當於從下拉列表中選擇項目，今天收獲頗多，下面給大家演示一下Spinner的使用(分別使用ArrayAdapter
Android Notification 樣式！
代碼中用的自定義常量 public static final int TYPE_Normal = 1; public static final int TYP
android4.0 USB Camera實例(三)UVC
前面我寫了兩篇文章說明了zc301的實現 具體請看 http://blog.csdn.net/hclydao/article/details/21235919 下面順
MSM8909+Android5.1.1 SPI驅動開發(PSAM部分)
MSM8909+Android5.1.1SPI驅動開發(PSAM部分) 1. PSAM部分的硬件設計 圖1CS 片選信號SCK 時鐘信號MISO 主設
