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
