byte处理的几种方法

/**

* 字符串转16进制byte
* @param
* @return
* @throws Exception
* @author hw
* @date 2018/10/19 9:47
*/
private static byte hexStr2Str(String hexStr) {
String str = "0123456789abcdef";
char[] hexs = hexStr.toCharArray();
int n = 0;
n = str.indexOf(hexs[0]) * 16;
n += str.indexOf(hexs[1]);
byte bytes = (byte) (n & 0xff);
return bytes;
}

输入："80"     

输出：0x80 , 打印出为  -128

注：

0x80 表示 128，（0x 代表 16 进制，8 * 16¹ + 0 * 16º = 128），128 的二进制是 10000000，即 2 的 7 次方。
byte 共有 8 位，表示范围是 -128 ~ 127，二进制即 10000000 ~ 01111111，第一位为符号位，1 表示负数，0 表示整数，11111111 即表示 -127，10000000 比较特殊，表示 -128。

所以，0x80 本来是整数的 128，二进制 00000000000000000000000010000000 （Java 中整数4个字节32位）。(byte)0x80，将其转换为 byte，即截取最后 8 位，即 10000000，就是 byte 中的 -128。

 

 

/**
* 将16进制字符串转换为byte[]
*
* @param str
* @return
*/
public static byte[] toBytes(String str) {
if(str == null || str.trim().equals("")) {
return new byte[0];
}
byte[] bytes = new byte[str.length() / 2];
for(int i = 0; i < str.length() / 2; i++) {
String subStr = str.substring(i * 2, i * 2 + 2);
bytes[i] = (byte) Integer.parseInt(subStr, 16);
}
return bytes;
}

 public static void main(String[] args) throws UnsupportedEncodingException {
String str = "80b58be8af95";
System.out.println("转换后的字节数组：" + Arrays.toString(toBytes(str)));
}

输出：

转换后的字节数组：[-128, -75, -117, -24, -81, -107]

 

 

/**
* 将数组以字符串形式存储
* @param
* @return
* @throws Exception
* @author hw
* @date 2018/10/19 9:45
*/
public static void saveFile2(byte[] bfile, String filename) throws IOException {
String fileURI ="D:\" + filename;
try {
File file = new File(fileURI);
if(!file.exists()){
file.createNewFile();
}
FileWriter fw = new FileWriter(file);
BufferedWriter out = new BufferedWriter(fw);
out.write(toHexString1(bfile));
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static String toHexString1(byte[] b){
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < b.length; ++i){
buffer.append(toHexString1(b[i]));
}
String str =
buffer.toString().substring(0,buffer.length()-1);
return str;
}
public static String toHexString1(byte b){
String s = Integer.toHexString(b & 0xFF);
if (s.length() == 1){
return "0" + s +",";
}else{
return s+",";
}
}

输入：byte[] bytes1 = { (byte)0xE2, (byte)0xa8, 0x34, (byte)0x80,(byte)0x91,0x22,0x33,0x44,0x55,0x66,0x77};
输出：E2, a8,34,80,91,22,33,44,55,66,77

 

 

/**
* 读取文件
* @param
* @return
* @throws Exception
* @author hw
* @date 2018/10/17 19:59
*/
public static byte[] readFile(String filePath) throws IOException {
File file = new File(filePath);
ByteArrayOutputStream out = null;
FileInputStream in =null;
try {
in = new FileInputStream(file);
out = new ByteArrayOutputStream();
byte[] b = new byte[1024];
int i = 0;
while ((i = in.read(b)) != -1) {
String str = new String(b,0,i);
out.write(str.getBytes(), 0, str.getBytes().length);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
out.close();
in.close();
}
byte[] bytes = out.toByteArray();
return bytes;
}

 

 

 

/**
* 读取文件存为byte[]
* @param
* @return
* @throws Exception
* @author hw
* @date 2018/10/19 9:48
*/
@ResponseBody
@RequestMapping(value = "/fileToByte", method = RequestMethod.GET)
public void fileToByte() throws Exception {
String filePath1 = "D:\test1.txt";
byte[] bytes1 = readFile(filePath1);
String str1= new String (bytes1);
String[] strs1 = str1.split(",");
String filePath2 = "D:\test2.txt";
byte[] bytes2 = readFile(filePath2);
String str2 = new String(bytes2);
String[] strs2 = str2.split(",");
byte[] bytes3 = new byte[strs2.length];
for(int i = 0 ; i<strs2.length ; i++){
bytes3[i] =hexStr2Str(strs2[i]);
}
//
String[] strs1={"2","5","7","9"};
//
String[] strs2 = {"e2","af","34","80","11","22","33","44","55","66","77"};
int start = 0;
int end = 0;
for(int i = 0; i<strs1.length;i++){
end = Integer.valueOf(strs1[i]);
byte[] byte_1 = new byte[end - start];
System.arraycopy(bytes3, start, byte_1, 0, end - start);
start = end;
bytes.offer(byte_1);
System.out.println("处理文件当前队列大小" + bytes.size());
}
}