hex 文件格式是可以燒寫到單片機中，被單片機執行的一種文件格式，生成Hex文件的方式有很多種，可以通過不同的編譯器將C程序或者匯編程序編譯生成hex。 ———— 百度百科。
總的思路就是，把 hex 文件中的16進制字符串，每兩個字符串解析成一個byte元素，寫入byte數組，再把byte數組寫入文件，文件后綴名定義為 .bin，就得到了二進制 bin 文件。
首先介紹一下 hex 文件的格式，以文件中某一行字符串（16進制）為例：
:10 0830 00 020C5D0224B3FFFFFFFFFFFFFFFFFFFF 7E
10，長度，轉換成10進制，也就是16B 大小，這里是32個字符，因為16進制中，2個字符占一個字節，可以不管。
0830，地址，轉換成10進制好計算，數據存入字節數組時，可以當做數組下標來使用，方便計算兩個地址間的差值。
00，這里表示數據記錄，還有其他類型百度便知，可以不管。
02...FF，數據部分。主要就是把這一部分轉成bin文件。
7E，校驗使用，可以不管。
備注：
- hex 文件中都是16進制的字符串
- 地址位是4位，最大FFFF也只能表示65535B（轉換成10進制）的數據，如果數據超過這個大小，地址位就需要歸0000，開始重復。當然，不一定非要到最大的位置才歸0，也可以提前，取決于生成hex 文件的代碼。一般地址開始重復的時候，都會有一個重復標識的行。
- 第一次循環開始的地址是0800，之后地址位的循環都是從0000 開始的
:020000080000FA 【開始循環的標識行】
:020800003003C3 【第一次循環的首地址是0800】
:10083000020C5D0224B3FFFFFFFFFFFFFFF987237E
:10084000FFFFFFFFFFFFFFFFFFFFFF021D03876487
:10085000FFFFFFFFFFFFFFFFFFFFFF022C01624961
......
:10FFE00008123EFF7909123C2F790A12338F790BE0
:10FFF000123F3B790C122E020083D082020C75FFC2【地址位到了FFF0結束】
:020000080001F9 【開始循環的標識行】
:1000000074F612187C90070F74FEF0A304F09007AA 【第二次循環開始，首地址都變成了0000】
:1000100012F0900FEAF07A018A0A750B00740278C9
:100020000A1217F9740F250AF87407350BF9EA88D4
- hex 文件中的數據可能是有序的，也可能無序，每個公司hex文件有所不同。
- 本例的hex文件的數據排列有序，即單次地址循環中，地址位是從小到大的
- 本例需要實現兩種結束方式，代碼中用type區分，1-碰到 3行數據部分全是F 時結束，2-數組滿了200K就結束，如下例子中最后3行就是數據部分全是F。
:103520009AF8E14BF9E3FAE9FB012C57C082C083C3
:10353000900C34EEFFD083D0DEF20CAAA20C650200
:103540000C75C0A2CC83A0EC3F7EE0FAD083D08211
:10355000020C75FFFFFFFFFFFFFFFFFFFFFFFFFFF5
:10356000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6B
:10357000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5B
:10358000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF4B
以上就是需要注意的點，也是代碼中主要的業務邏輯，可以理解為需求文件。上代碼
import java.io.*;
public class Test {
private static final int ByteSize = 200*1024; //讀取的字節數
private static final String firstLinePrefix = ":02000008"; //地址循環行的標識
private static final Integer firstAddressPrefix_10 = 2048 ; //0800，第一次循環的第一個地址位的16進制字符串，轉換成十進制是2048
private static final int dataMaxCharNum = 32; //每行數據最多32字符，16個字節（16進制2個字符占一個字節）
private static final String compareString = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"; //數據部分全F
public static void main(String[] args) {
int type = 2;
File mfile = new File("C:\\Users\\XYP\\Desktop\\HexToBin\\IS2P-KR-OAD.hex");
InputStream inputStream = null;
BufferedReader bufferedReader = null;
FileOutputStream fileOutputStream = null;
try {
if (mfile == null) {
System.out.println("文件為空");
}
inputStream = new FileInputStream(mfile);
//轉成 reader 以 行 為單位讀取文件
bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
//當前行字符串
String hexLineStr = null;
//當前行數
int hexLineNum = 0;
//當前行的地址位
Integer hexLineAddress = null;
//連續三行數據全F終止
int hexLineNumForF = 0;
//目前數據保存的下標位置
int offset = 0;
//地址歸零從新開始時，保存前面地址的偏移量
int offsetAdd = 0;
//每次循環的首地址（第一次是0800，后面循環都是從0000開始了）代碼中以十進制來匹配計算
int firstAddress = firstAddressPrefix_10;
//200k固定長度的數組
byte[] bytes = new byte[ByteSize];
//選擇了3F行結束時賦值的數組
byte[] bytes2 = null;
//初始化數組為全FFF
fillFToByteArray(bytes,compareString);
while ((hexLineStr = bufferedReader.readLine())!=null){
hexLineNum++;
if(hexLineStr.startsWith(firstLinePrefix)){
if(hexLineNum!=1){
firstAddress = 0;
offsetAdd = offset+dataMaxCharNum/2;
}
System.out.println("循環，位置偏移："+offset+" 開始地址："+firstAddress);
continue;
}
//地址為轉換成十進制
hexLineAddress = Integer.parseInt(hexLineStr.substring(3,7),16);
//獲取數據部分
String preData = hexLineStr.substring(9);
String data = preData.substring(0,preData.length()-2);
//數據部分小于32個字符串的話，要用F填充滿
if(data.length()<dataMaxCharNum){
data = fillHexString(data);
}
//遇到全F就累計+1
if(data.equals(compareString)){
hexLineNumForF++;
}else { //一旦全F斷了就歸0
hexLineNumForF=0;
}
//由于地址存在歸0的情況，所以要注意每次循環首地址的變化，以及上次循環結束時，地址的下標
offset = hexLineAddress-firstAddress+offsetAdd;
//進入該if就表示數組滿了，需求是最大200k
if(hexStringToByteArray(data,bytes,offset)==1){
break;
}
//當碰到3行數據全是F的時候，把數據復制到另一個數組，注意數組大小，是根據地址下標來計算的
if(hexLineNumForF>=3&&type==1){
bytes2 = new byte[offset+dataMaxCharNum/2];
for(int i = 0 ; i < bytes.length ; i ++){
bytes2[i] = bytes[i];
if(i==bytes2.length-1){
break;
}
}
break;
}
}
fileOutputStream = new FileOutputStream("C:\\Users\\XYP\\Desktop\\HexToBin\\IS2P-KR-OAD_200K.bin");
if(type==1){
fileOutputStream.write(bytes2);
}else {
fileOutputStream.write(bytes);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(inputStream!=null){
inputStream.close();
}
if(bufferedReader!=null){
bufferedReader.close();
}
if(fileOutputStream!=null){
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//初始化數組成全F
public static void fillFToByteArray(byte[] b,String s){
int len = s.length();
for(int i = 0 ; i < b.length ; i ++){
for(int j = 0 ; j < len ; j +=2 ){
b[i] = (byte) ((Character.digit(s.charAt(j), 16) << 4) + Character
.digit(s.charAt(j + 1), 16));
}
}
}
//數據要填充滿32個字符
private static String fillHexString(String s){
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(s);
while (stringBuilder.length()<dataMaxCharNum){
stringBuilder.append("F");
}
return stringBuilder.toString();
}
//16進制字符串轉字節數組,如果數組滿了，就返回1，否則返回0
public static int hexStringToByteArray(String s,byte[] b,int offset) {
int len = s.length();
for (int i = 0; i < len; i += 2) {
// 兩位一組，表示一個字節,把這樣表示的16進制字符串，還原成一個字節
b[offset] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character
.digit(s.charAt(i + 1), 16));
if(offset==b.length-1){
return 1;
}
offset++;
}
return 0;
}
}
之所以調用 fillFToByteArray() 函數，是因為有時候地址并不是連續的，跳過部分需要用F填充，初始化的字節數組每個元素默認是0，往數組里寫的時候，是根據地址轉換成10進制對應的下標來直接對某個元素賦值的，所以最后生產的文件，跳過的部分會全是0，所以干脆初始化數組是全F。如下第三行就比第二行跳過了32個字節。
:020000080000FA
:020800003003C3 【有效數據開始的行】
:10083000020C5D0224B3FFFFFFFFFFFFFFF987237E
:10084000FFFFFFFFFFFFFFFFFFFFFF021D03876487
:10085000FFFFFFFFFFFFFFFFFFFFFF022C01624961
