精华内容
下载资源
问答
  • Java二进制文件解析之最终解析
    2021-02-12 17:42:31

    读取二进制文件,并将二进制文件转为byte[],方便后续的二进制数组截取,详细内容如下,如图所示:

    @SuppressWarnings("resource")

    public byte[] getContent(String filePath) throws IOException {

    File file = new File(filePath);

    long fileSize = file.length();

    if (fileSize > Integer.MAX_VALUE) {

    System.out.println("file too big...");

    return null;

    }

    FileInputStream fi = new FileInputStream(file);

    byte[] buffer = new byte[(int) fileSize];

    int offset = 0;

    int numRead = 0;

    while (offset < buffer.length

    && (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {

    offset += numRead;

    }

    // 确保所有数据均被读取

    if (offset != buffer.length) {

    throw new IOException("Could not completely read file "    + file.getName());

    }

    fi.close();

    return buffer;

    }

    更多相关内容
  • 本篇文章主要介绍了java实现解析二进制文件的方法(字符串、图片),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要给大家介绍了利用Java读取二进制文件的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者使用java具有一定的参考学习价值,需要的朋友们下面跟着小编来一起学习学习吧。
  • java解析二进制文件(.dat)

    千次阅读 2020-06-03 15:43:45
    该文章讲的仅仅是通过java对于二进制文件解析操作 首先说明一下查看.dat文件的工具:C32Asm,可以通过该工具查看.dat文件,查看模式可以选择十六进制、十进制(我们最终要的是十进制)、八进制、二进制 注:开始...

    该文章讲的仅仅是通过java对于二进制文件解析操作

    首先说明一下查看.dat文件的工具:C32Asm,可以通过该工具查看.dat文件,查看模式可以选择十六进制、十进制(我们最终要的是十进制)、八进制、二进制

    注:开始解析文件之前,需先了解所要解析的文件的数据结构/每个数据项所占的字节长度

    其实所谓的数据解析和读取普通的文件一样操作,只不过大多数人不了解二进制、十进制。。。。。

    通过这种方式读取出来的内容为10进制,也就是我们日常生活中接触的数值,比如:100RMB,这个100就是十进制(打个比喻,让大家更好的理解一下,不喜勿喷)

    重点是在于进制之间的转换,下面先来一段读取.dat文件的代码

    1、读取二进制文件(.dat)

    public class Main {

    public static void main(String[] args) {

    //文件所在路径

    String filePath = "D:\\test";

    //文件名称

    String fileName = "123.dat";

    // 源文件路径

    File startFile = new File(filePath + fileName);

    FileInputStream in = null;

    try {

    in = new FileInputStream(filePath + fileName);

    int data = 0;

    while ((data = in.read()) != -1) {

    System.out.println("文件内容输出:"+data);

    }

    }catch (Exception e) {

    e.printStackTrace();

    } finally {

    }

    }

    }

    }

    2、进制转换(将上面的代码先copy一份,进行微小的改动,会标红)

    因为在实际情况中会是多个字节组装成一个数据项,本程序读取文件是一个字节一个字节读取的(大家可以根据自身情况修改),所以需要将每个字节进行存储,存储够一个数据项所需字节长度后,进行统一转换

    public class Main {

    public static void main(String[] args) {

    //每次循环需要+1,用来计数

    int num = 0;

    //给数组赋予下标

    int k= 0;

    //这个数组就是存储字节数据,然后统一进行转换

    int[] messDate = new int[20];

    //文件所在路径

    String filePath = "D:\\test";

    //文件名称

    String fileName = "123.dat";

    // 源文件路径

    File startFile = new File(filePath + fileName);

    FileInputStream in = null;

    try {

    in = new FileInputStream(filePath + fileName);

    int data = 0;

    while ((data = in.read()) != -1) {

    //如果能确定数据项所占字节长度是5

    messDate[k] = data;

    if(k==4){

    String str = tenTransformSixteen(messDate,k);

    System.out.println("文件内容输出:"+str);

    k=0;

    }

     

     

    k+=1;

    num+=1;

    }

    }catch (Exception e) {

    e.printStackTrace();

    } finally {

    }

    }

    }

    }

    /**

    * 十进制转十六进制转十进制

    * 需要将数组中每一个十进制字节转换成十六进制,然后拼接到一起,统一转换成十进制

    * @param data字节数组

    * @param k数组长度

    * @return

    */

    public String tenTransformSixteen(int[] data, int k) {

    String str = "";

    for (int i = 0; i < k; i++) {

    // data为十进制,将每个十进制解析成十六进制,然后将数组中数值一起解析成十进制

    String hexString = Integer.toHexString(data[i]);

    if (hexString.length() == 1) {

    hexString = "0" + hexString;

    }

    str = str + hexString;

    }

    str = String.valueOf(Long.valueOf(str, 16));

    return str;

    }

    展开全文
  • java 解析二进制文件保存为txt文件

    千次阅读 2018-12-27 13:58:22
    解析二进制文件

    java 解析二进制文件保存为txt文件
    本文包含二进制解析,遍历文件夹下的文件,生成对应得文件夹以及文件,日期转换的知识点

    import java.io.*;
    import java.math.BigDecimal;
    import java.text.DecimalFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.concurrent.*;
    
    /*
    SL 二进制文件解析
     */
    public class ReadSL {
        //阻塞队列线程安全
        private static BlockingQueue<File> queue = new LinkedBlockingQueue<File>(10000);
        //线程池
        private static ExecutorService threadPool = Executors.newFixedThreadPool(2);
    
        public static void main(String[] args) throws Exception {
    
            //监控线程
            threadPool.execute(new Runnable() {
                public void run() {
    
                    while (true) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        int size = queue.size();
                        System.out.println("还有:" + size + "个元素");
    
                        threadPool.shutdown();
    
                    }
    
    
                }
            });
    
            for (int i = 1; i <= 1; i++) {
                threadPool.execute(new Runnable() {
                    public void run() {
    
                        while (true) {
    
                            try {
                                //从队列中获取文件
                                File file = queue.take();
                                parseText(file);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }
                });
            }
            traverseFolder2("D:\\test");
        }
    
        //字节数组转单精度
        public static float  bytetofloat(byte[] b) {
    
            int accum = 0;
            accum = accum | (b[0] & 0xff) << 0;
            accum = accum | (b[1] & 0xff) << 8;
            accum = accum | (b[2] & 0xff) << 16;
            accum = accum | (b[3] & 0xff) << 24;
    
           float accumf= Float.intBitsToFloat(accum);
            BigDecimal bd = new BigDecimal(accumf);
            accumf= bd.setScale(6,BigDecimal.ROUND_HALF_UP).floatValue();
            return accumf;
        }
    
        //字节数组转int
        public static int bytetoInt(byte[] b) {
            int jd = 0;
            int jd0 = b[0] & 0xff;// 最低位
            int jd1 = b[1] & 0xff;
            int jd2 = b[2] & 0xff;
            int jd3 = b[3] & 0xff;
            jd3 <<= 24;
            jd2 <<= 16;
            jd1 <<= 8;
            jd = jd0 | jd1 | jd2 | jd3;
            return jd;
        }
    
        //时间转换
        public static String getDate(int t) throws ParseException {
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String historyTime = "1970-01-01 08:00:00";
            Date date = dateFormat.parse(historyTime);
            Date newDate = addSeconds(date, t);
            return dateFormat.format(newDate);
        }
        private static Date addSeconds(Date date, int seconds) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.SECOND, seconds);
            return calendar.getTime();
        }
    
    
        public static void traverseFolder2(String path) throws Exception {
    
            //空文件夹处理
            File file = new File(path);
            if (file.exists()) {
                File[] files = file.listFiles();
                if (files.length == 0) {
                    return;
                } else {
                    for (File file2 : files) {
                        if (file2.isDirectory()) {
                            traverseFolder2(file2.getAbsolutePath());
                        } else {
                            //将文件放入阻塞队列中
                            queue.put(file2);
                        }
                    }
                }
            } else {
                System.out.println("文件不存在!");
            }
        }
    
        public static void parseText(File file) throws Exception {
            String result0 = null;
            //文件的路径
            File infile = new File(file.getAbsolutePath());
            //文件名称
            String name = infile.getName();
            //路径
            String absolutePath = infile.getAbsolutePath();
            //输入流
            InputStream bis = new FileInputStream(infile);
            //输出路径
            String outPath = "D:\\parseData";
            //切割文件路径
            String[] split = absolutePath.split("\\\\");
            byte[] b = new byte[1022];
            int len = 0;
            int count = 0;
            //txt文件暂不处理
            if (infile.getName().substring(name.length() - 4, name.length()).equals(".txt")) {
                return;
            } else {
                String time = "";
                long historyMillons = 0;
                String listStr = "";
                String listStr2="";
                ArrayList<String> list = new ArrayList<String>();
                //时间
                long historyTimeMillins=0;
    
                String path1 = "\\" + split[1] + "\\" + split[2] + "\\" + split[3] + "\\" + split[4] + "\\" + split[5] + "\\";
                outPath = outPath + path1 + infile.getName().substring(0, name.length() - 3) + ".txt";
                //创建文件
                createFiles(outPath);
                //输出流,追加写入文件
                BufferedWriter bw = new BufferedWriter(new FileWriter(outPath,true));
                //保留小数点后六位数字
                DecimalFormat format = new DecimalFormat("0.000000");
                while ((len = bis.read(b)) != -1) {
                    count++;
                    if (count == 1) {
                        //版本号
                        byte[] b1 = { b[1], b[2], b[3], b[4], b[5], b[6],b[7],b[8]};
                        //传感器类型简写
                        byte[] b2 = {b[9], b[10]};
                        //传感器类型全称
                        byte[] b3 = {b[12], b[13], b[14], b[15], b[16], b[17], b[18], b[19]};
                        //时间
                        byte[] b4 = {b[20], b[21], b[22], b[23]};
                        //传感器编号
                        byte[] b5 = {b[25], b[26], b[27], b[28], b[29], b[30], b[31], b[32]};
                        String bbh = new String(b1, "UTF-8");
                        //System.out.println("版本号:" + bbh);
                        String jianXie = new String(b2, "UTF-8");
    
                        String fullName = new String(b3, "GBK");
    
                        //时间操作  字节数组转换long类型
                        long s0 = b4[0] & 0xff;// 最低位
                        long s1 = b4[1] & 0xff;
                        long s2 = b4[2] & 0xff;
                        long s3 = b4[3] & 0xff;
                        s1 <<= 8;
                        s2 <<= 16;
                        s3 <<= 24;
                        historyMillons = s0 | s1 | s2 | s3;
                        time = getDate((int) historyMillons);
                        // System.out.println("采集时间:" + time);
    
                        String bianHao = new String(b5, "utf-8");
                        //  System.out.println("传感器编号:" + bianHao);
    
                        //频率 单精度
                        byte[] b6 = {b[33], b[34], b[35], b[36]};
                        float pinLv = bytetofloat(b6);
    
                        //采样精度 32位整型
                        byte[] b7 = {b[37], b[38], b[39], b[40]};
                        int jingDu = bytetoInt(b7);
                        //放大倍数
                        byte[] b8 = {b[41], b[42], b[43], b[44]};
                        int beiShu = bytetoInt(b8);
    
                        //传感器灵敏度
                        byte[] b9 = {b[45], b[46], b[47], b[48]};
                        float minGanDu = bytetofloat(b9);
                        //文件头信息结束标志 $
                        //  byte[] b11 = {b[49]};
                        //System.out.println(new String(b11));
                        //文件头信息
                        result0 = bbh + "\t" + jianXie + "\t" + fullName + "\t" + time + "\t" + bianHao + "\t" + pinLv + "\t" + jingDu + "\t" + beiShu + "\t" + minGanDu + "\t";
                       //System.out.println(b.length);
                        //真正数据部分
                        for (int j = 50; j <= len - 4; j += 4) {
                            byte[] b12 = {b[j], b[j + 1], b[j + 2], b[j + 3]};
                            float cjsj = bytetofloat(b12);
                            String flToStr = String.valueOf(cjsj);
                            //取消科学计数法
                           flToStr= format.format(cjsj);
                            historyTimeMillins=historyMillons * 1000 + 50 * ((j - 50) / 4);
                            flToStr =  historyTimeMillins+ " " + flToStr;
                            list.add(flToStr);
                        }
                        b=new byte[102400*10];
                    }
                    else {
                        for (int i = 0; i < len - 3; i+=4) {
                            byte[] b13 = {b[i], b[i + 1], b[i + 2], b[i + 3]};
                            float cjsj = bytetofloat(b13);
                            //取消科学计数法
                            String format1 = format.format(cjsj);
                            format1= historyTimeMillins+ 50 * (i / 4) + " " + format1;
                            //System.out.println("采集数据:" + cjsj);
    
                            list.add(format1);
                            //listStr2 += flToStr + "\r\n";
                        }
    
    
                        }
                }
    
                //文件追加写入
                bw.write(result0+"\r\n");
                //System.out.println(list.size());
                for (int i =0;i<list.size();i++){
                    //换行写入
                    bw.write(list.get(i)+"\r\n");
                }
                bw.flush();
                    bis.close();
                    bw.close();
                }
            }
    
            public static void createFiles (String outPath) throws IOException {
    
    
                File outFile = new File(outPath);
                //输出路径
                File parentFile = outFile.getParentFile();
                if (!parentFile.exists()) {
                    parentFile.mkdirs();
                }
    
                outFile.createNewFile();
            }
    
            public static void createDir (String outPath){
                File outFile = new File(outPath);
                //输出路径
                File parentFile = outFile.getParentFile();
                if (!parentFile.exists()) {
                    parentFile.mkdirs();
                }
                outFile.mkdirs();
            }
        }
    
    展开全文
  • 1、需求说明,实现细节要求:解析二进制文件 files\case10\binary,其中包含一个字符串和一张图片,数据文件格式为字符串数据长度(2字节)+字符串内容+图片数据长度(4字节)+图片数据,数据长度均为数据字节长度,高位...

    1、需求说明,实现细节要求:

    解析二进制文件 files\case10\binary,其中包含一个字符串和一张图片,数据文件格式为字符串数据长度(2字节)+字符串内容+图片数据长度(4字节)+图片数据,数据长度均为数据字节长度,高位在后,字符串为UTF-8编码,请解析,输出字符串内容,图片文件保存为files\case10\test.png。

    2、实现代码:

    /**

    *

    */

    package com.igen.case10;

    import java.io.File;

    import java.io.FileInputStream;

    import java.io.FileNotFoundException;

    import java.io.FileOutputStream;

    import java.io.IOException;

    import java.io.InputStream;

    import java.net.URISyntaxException;

    /**

    *

    * @ClassName Case10

    * @Description TODO

    *

    * @author wjggwm

    * @data 2017年2月7日 上午11:46:25

    */

    public class Case10 {

    static final String fileName = "/test.png";

    static final String filePath = "D:/files/case10";

    static final String sourceFileName = "binary";

    public static void main(String[] args) {

    try {

    readFile(Case10.class.getResource(sourceFileName).toURI().getPath());

    } catch (URISyntaxException e) {

    e.printStackTrace();

    }

    }

    /**

    *

    * @Description 解析二进制文件

    * @param sourceFileName

    *

    * @author wjggwm

    * @data 2017年2月7日 上午11:47:12

    */

    public static void readFile(String sourceFileName) {

    InputStream in = null;

    try {

    in = new FileInputStream(sourceFileName);

    // 读取字符串数据长度字节

    byte[] txtLenByte = new byte[2];

    in.read(txtLenByte);

    int txtlen = byte2ToUnsignedShort(txtLenByte, 0);

    // 读取字符串字节

    byte[] txtByte = new byte[txtlen];

    in.read(txtByte);

    //字符串为UTF-8编码

    String txt = new String(txtByte, "UTF-8");

    // 输出字符串

    System.out.println(txt);

    // 读取图片数据长度

    byte[] imgLenByte = new byte[4];

    in.read(imgLenByte);

    int imgLen = byte4ToInt(imgLenByte, 0);

    // 读取图片数据

    byte[] img = new byte[imgLen];

    in.read(img);

    // 生成图片文件

    saveToImgByBytes(filePath, fileName, img);

    } catch (FileNotFoundException e) {

    e.printStackTrace();

    } catch (IOException e) {

    e.printStackTrace();

    } finally {

    if (in != null) {

    try {

    in.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    }

    /**

    *

    * @Description 将字节写入文件

    * @param imgName

    * @param imgByte

    *

    * @author wjggwm

    * @data 2017年2月7日 上午11:07:45

    */

    public static void saveToImgByBytes(String filePath, String imgName, byte[] imgByte) {

    try {

    File dic = new File(filePath);

    if (!dic.exists()) {

    dic.mkdirs();

    }

    File image = new File(filePath + imgName);

    if (!image.exists()) {

    image.createNewFile();

    }

    FileOutputStream fos = new FileOutputStream(image);

    fos.write(imgByte);

    fos.flush();

    fos.close();

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    /**

    *

    * @Description byte数组转换为无符号short整数

    * @param bytes

    * @param off

    * @return

    *

    * @author wjggwm

    * @data 2017年2月7日 上午11:05:58

    */

    public static int byte2ToUnsignedShort(byte[] bytes, int off) {

    // 注意高位在后面,即大小端问题

    int low = bytes[off];

    int high = bytes[off + 1];

    return (high << 8 & 0xFF00) | (low & 0xFF);

    }

    /**

    *

    * @Description byte数组转换为int整数

    * @param bytes

    * @param off

    * @return

    *

    * @author wjggwm

    * @data 2017年2月7日 上午11:07:23

    */

    public static int byte4ToInt(byte[] bytes, int off) {

    // 注意高位在后面,即大小端问题

    int b3 = bytes[off] & 0xFF;

    int b2 = bytes[off + 1] & 0xFF;

    int b1 = bytes[off + 2] & 0xFF;

    int b0 = bytes[off + 3] & 0xFF;

    return (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;

    }

    }

    展开全文
  • java读取二进制文件

    2013-01-09 22:53:24
    java读取二进制文件
  • JAVA读写二进制文件

    2012-06-01 16:09:21
    JAVA读写二进制文件
  • 一、Java Class文件是什么《The JavaTM Virtual Machine Specification》(Second Edtion)中有表述:Java Class文件由8位字节流组成,所有的16位、32位和64位数据分别通过读入2个、4个和8个字节来构造,多字节数据...
  • 本篇文章主要介绍了JAVA中读取文件(二进制,字符)内容的方法总结,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Filefile=newFile("D:/Users/yao/Desktop/test/2.rec");if(file.exists()){try{FileInputStreamin=newFileInputStream(file);DataInputStreamdis=newDataInputStream(in);byte[]itemB...File file = new File("D:/Us...
  • public class SeniorDemo { private int num = 1; public final String info = "hello world";... } } jclasslib查看字节码反解析的结果 二进制字节码解析 解析最关键的部分是常量池。 解析最负载的部分是方法。
  • import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class FileOperation { public static void...
  • 模拟dto发送的二进制图片:用java 操作 二进制与图片 转换 package com.wxm.util; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream;...
  • 解读字节码文件二进制类格式实际上是由 JVM 规范定义的。通常这些类表示是由编译器从 Java 语言源代码生成的,而且它们通常存储在扩展名为 .class 的文件中。但是,这些特性都无关紧要。就 JVM 而言,重要的部分不是...
  • c的同事将流量数据以二进制形式追加写入文件中,需要java端读取并解析,发送至kafka。 c的数据类型 Specifier Common Equivalent Signing Bits Bytes Minimum Value Maximum Value int8_t signed char ...
  • 几乎每个Java应用程序都会创建和处理集合。 它们是许多编程任务的基础:它们使您可以对数据进行分组和处理。 例如,您可能想创建一组银行交易来表示客户的对帐单。 然后,您可能需要处理整个集合以找出客户花费了...
  • importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importsun.misc.BASE64Decoder;publicStringgetPicFromStreams(){Stringstr;//存放二进制的流BASE64Decoderdecoder=newBASE64Dec...
  • 1.将数据写入二进制文件[java] view plain copy public void wirteBinary() { try { DataOutputStream os = new DataOutputStream( new BufferedOutputStream(new FileOutputStrea...
  • 引入:文件可以分为你两种类型进行存储,一是以文本的格式存储,其他的都是以二进制的方式进行存储的,比如:(100100001111).在文本的读取中,我们有Scanner和PrintWriter方法中文本中读入和写出数据。读取文本数据...
  • 解析:首先是读取字节:/*** 读取输入流中指定字节的长度* * 输入流** @param length 指定长度* @return 指定长度的字节数组*/public static byte[] readBytesFromTo(byte[] buffer, int from, int length) {byte[] ...
  • 主要介绍了java读取图片并转化为二进制字符串的实例代码,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • JAVA中的浮点数与二进制 先来看一段简单的代码 public static void main(String[] args) { System.out.println(0.1+0.2); } 打印结果如下: 0.30000000000000004 //为什么0.1+0.2不等于0.3? 为什么会出现这种...
  • 前言此文主要给大伙介绍了关于Java读取二进制文件的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧。读Hex写CSVdata目录下有little-endian bin文件,2个字节代表一个数字。bin存储的...
  • 一,计算某个正数的二进制表示法中 1 的个数 1 //求解正数的二进制表示法中的 1 的位数2 private static int countBit(intnum){3 int count = 0;4 for(; num > 0; count++)5 {6 num &= (num - 1);7 }8 ...
  • 查看了很多资料。对方返回的是415,类型错误应该使用Content-Type = "*/*"
  • JAVA之读取二进制文件

    万次阅读 2018-10-26 22:56:03
    目的在于:将一个二进制文件中的数据读取出来,其中数据包括点的位置信息和压力值及状态。将这些数据画作图像的形式展示。 本小程序分为以下几部分: (1)读取二进制文件;其中需要考虑二进制文件读出来的是十...
  • Java中有一个内置字节类型,你可以使用InputStream#read(byte[])读入byte []缓冲区并使用OutputStream#write(byte[], int, int)写入OutputStream,所以没有问题.关于你的消息 – 正如你所说的那样,你一次获得的最...
  • 它应同时适用于文本文件和二进制文件(例如imgs).我对文本文件没有任何问题,它可以完美工作,但是对二进制文件有一些麻烦.首先,我声明一个BufferedReader(用于读取标题和文本文件)和一个DataInput流:BufferedReader ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,949
精华内容 63,579
关键字:

java 解析二进制

java 订阅