精华内容
下载资源
问答
  • 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();
            }
        }
    
    展开全文
  • java 读写二进制文件

    千次阅读 2012-11-12 20:32:15
    JAVA二进制文件读写代码 /** * 二进制读写文件 */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream;
    JAVA二进制文件读写代码
    1. /**    
    2.  * 二进制读写文件    
    3.  */     
    4. import java.io.BufferedInputStream;      
    5. import java.io.BufferedOutputStream;      
    6. import java.io.DataInputStream;      
    7. import java.io.DataOutputStream;      
    8. import java.io.FileInputStream;      
    9. import java.io.FileOutputStream;      
    10.      
    11. public class MainClass      
    12. {      
    13.     /**    
    14.      * java.io包中的OutputStream及其子类专门用于写二进制数据。    
    15.      * FileOutputStream是其子类,可用于将二进制数据写入文件。    
    16.      * DataOutputStream是OutputStream的另一个子类,它可以    
    17.      * 连接到一个FileOutputStream上,便于写各种基本数据类型的数据。    
    18.      */     
    19.     public void writeMethod1()      
    20.     {      
    21.         String fileName="c:/kuka1.dat";      
    22.         int value0=255;      
    23.         int value1=0;      
    24.         int value2=-1;      
    25.         try     
    26.         {      
    27.             //将DataOutputStream与FileOutputStream连接可输出不同类型的数据      
    28.             //FileOutputStream类的构造函数负责打开文件kuka.dat,如果文件不存在,      
    29.             //则创建一个新的文件,如果文件已存在则用新创建的文件代替。然后FileOutputStream     
    30.             //类的对象与一个DataOutputStream对象连接,DataOutputStream类具有写      
    31.             //各种数据类型的方法。      
    32.             DataOutputStream out=new DataOutputStream(new FileOutputStream(fileName));      
    33.             out.writeInt(value0);      
    34.             out.writeInt(value1);      
    35.             out.writeInt(value2);      
    36.             out.close();      
    37.         } catch (Exception e)      
    38.         {      
    39.             e.printStackTrace();      
    40.         }      
    41.     }      
    42.     //对于大量数据的写入,使用缓冲流BufferedOutputStream类可以提高效率      
    43.     public void writeMethod2()      
    44.     {      
    45.         String fileName="c:/kuka2.txt";      
    46.         try     
    47.         {      
    48.             DataOutputStream out=new DataOutputStream(      
    49.                                  new BufferedOutputStream(      
    50.                                  new FileOutputStream(fileName)));      
    51.             out.writeInt(10);      
    52.             System.out.println(out.size()+" bytes have been written.");      
    53.             out.writeDouble(31.2);      
    54.             System.out.println(out.size()+" bytes have been written.");      
    55.             out.writeBytes("JAVA");      
    56.             System.out.println(out.size()+" bytes have been written.");      
    57.             out.close();      
    58.         } catch (Exception e)      
    59.         {      
    60.             e.printStackTrace();      
    61.         }      
    62.     }      
    63.     /**    
    64.      * 对二进制文件比较常见的类有FileInputStream,DataInputStream    
    65.      * BufferedInputStream等。类似于DataOutputStream,DataInputStream    
    66.      * 也提供了很多方法用于读入布尔型、字节、字符、整形、长整形、短整形、    
    67.      * 单精度、双精度等数据。    
    68.      */     
    69.     public void readMethod1()      
    70.     {      
    71.         String fileName="c:/kuka1.dat";      
    72.         int sum=0;      
    73.         try     
    74.         {      
    75.             DataInputStream in=new DataInputStream(      
    76.                                new BufferedInputStream(      
    77.                                new FileInputStream(fileName)));      
    78.             sum+=in.readInt();      
    79.             sum+=in.readInt();      
    80.             sum+=in.readInt();      
    81.             System.out.println("The sum is:"+sum);      
    82.             in.close();      
    83.         } catch (Exception e)      
    84.         {      
    85.             e.printStackTrace();      
    86.         }      
    87.     }      
    88.           
    89.     public void readMethod2()      
    90.     {      
    91.         try     
    92.         {      
    93.             FileInputStream stream=new FileInputStream("c:/kuka.dat");      
    94.             int c;      
    95.             while((c=stream.read())!=-1)      
    96.             {      
    97.                 System.out.println(c);      
    98.             }      
    99.         } catch (Exception e)      
    100.         {      
    101.             e.printStackTrace();      
    102.         }      
    103.     }      
    104. }    
    展开全文
  • 以16进制的形式查看java class二进制文件 人在码途 0.201 2018.11.02 17:12:28 字数 232 阅读 538 首先创建java文件 HelloWorld.java public class HelloWorld { public static void main(String[] args) { String s...

    以16进制的形式查看java class二进制文件

    首先创建java文件 HelloWorld.java

    public class HelloWorld {
    public static void main(String[] args) {
    String s = “Hollo World”;
    }
    }

    编译

    javac HelloWorld.java
    生成class文件 HelloWorld.class
    查看class 文件 打开文件 vim HelloWorld.class ,然后输入:%!xxd 就是以16进制显示class文件了,内容如下

    00000000: cafe babe 0000 0034 0011 0a00 0400 0d08 …4…
    00000010: 000e 0700 0f07 0010 0100 063c 696e 6974 …<init
    00000020: 3e01 0003 2829 5601 0004 436f 6465 0100 >…()V…Code…
    00000030: 0f4c 696e 654e 756d 6265 7254 6162 6c65 .LineNumberTable
    00000040: 0100 046d 6169 6e01 0016 285b 4c6a 6176 …main…([Ljav
    00000050: 612f 6c61 6e67 2f53 7472 696e 673b 2956 a/lang/String;)V
    00000060: 0100 0a53 6f75 7263 6546 696c 6501 000f …SourceFile…
    00000070: 4865 6c6c 6f57 6f72 6c64 2e6a 6176 610c HelloWorld.java.
    00000080: 0005 0006 0100 0b48 6f6c 6c6f 2057 6f72 …Hollo Wor
    00000090: 6c64 0100 0a48 656c 6c6f 576f 726c 6401 ld…HelloWorld.
    000000a0: 0010 6a61 7661 2f6c 616e 672f 4f62 6a65 …java/lang/Obje
    000000b0: 6374 0021 0003 0004 0000 0000 0002 0001 ct.!..
    000000c0: 0005 0006 0001 0007 0000 001d 0001 0001 …
    000000d0: 0000 0005 2ab7 0001 b100 0000 0100 0800 …*…
    000000e0: 0000 0600 0100 0000 0100 0900 0900 0a00 …
    000000f0: 0100 0700 0000 2000 0100 0200 0000 0412 … …
    00000100: 024c b100 0000 0100 0800 0000 0a00 0200 .L…
    00000110: 0000 0300 0300 0400 0100 0b00 0000 0200 …
    00000120: 0c0a …
    ~
    也可以使用Linux下的xxd命令,将二进制信息转换为16进制数据,使用方式为

    xxd HelloWorld.class HelloWorld.txt
    生成的HelloWorld.txt与通过:%!xxd是一样的

    二进制与16进制转换还有其他一些方式,如下:

    linux下查看二进制文件
    以十六进制格式输出:
    od [选项] 文件
    od -d 文件 十进制输出
    -o 文件 八进制输出
    -x 文件 十六进制输出
    xxd 文件 输出十六进制

    在vi命令状态下:
    :%!xxd :%!od 将当前文本转化为16进制格式
    :%!xxd -c 12 每行显示12个字节
    :%!xxd -r 将当前文本转化回文本格式

    在windows系统中使用WinHex软件来打开class文件可以查看到16进制格式的内容。

    展开全文
  • * 二进制读写文件 */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.FileInputStream; import ...
    /**
     * 二进制读写文件
     */
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class MainClass
    {
    	/**
    	 * java.io包中的OutputStream及其子类专门用于写二进制数据。
    	 * FileOutputStream是其子类,可用于将二进制数据写入文件。
    	 * DataOutputStream是OutputStream的另一个子类,它可以
    	 * 连接到一个FileOutputStream上,便于写各种基本数据类型的数据。
    	 */
    	public void writeMethod1()
    	{
    		String fileName="c:/kuka1.dat";
    		int value0=255;
    		int value1=0;
    		int value2=-1;
    		try
    		{
    			//将DataOutputStream与FileOutputStream连接可输出不同类型的数据
    			//FileOutputStream类的构造函数负责打开文件kuka.dat,如果文件不存在,
    			//则创建一个新的文件,如果文件已存在则用新创建的文件代替。然后FileOutputStream
    			//类的对象与一个DataOutputStream对象连接,DataOutputStream类具有写
    			//各种数据类型的方法。
    			DataOutputStream out=new DataOutputStream(new FileOutputStream(fileName));
    			out.writeInt(value0);
    			out.writeInt(value1);
    			out.writeInt(value2);
    			out.close();
    		} catch (Exception e)
    		{
    			e.printStackTrace();
    		}
    	}
    	//对于大量数据的写入,使用缓冲流BufferedOutputStream类可以提高效率
    	public void writeMethod2()
    	{
    		String fileName="c:/kuka2.txt";
    		try
    		{
    			DataOutputStream out=new DataOutputStream(
    								 new BufferedOutputStream(
    								 new FileOutputStream(fileName)));
    			out.writeInt(10);
    			System.out.println(out.size()+" bytes have been written.");
    			out.writeDouble(31.2);
    			System.out.println(out.size()+" bytes have been written.");
    			out.writeBytes("JAVA");
    			System.out.println(out.size()+" bytes have been written.");
    			out.close();
    		} catch (Exception e)
    		{
    			e.printStackTrace();
    		}
    	}
    	/**
    	 * 对二进制文件比较常见的类有FileInputStream,DataInputStream
    	 * BufferedInputStream等。类似于DataOutputStream,DataInputStream
    	 * 也提供了很多方法用于读入布尔型、字节、字符、整形、长整形、短整形、
    	 * 单精度、双精度等数据。
    	 */
    	public void readMethod1()
    	{
    		String fileName="c:/kuka1.dat";
    		int sum=0;
    		try
    		{
    			DataInputStream in=new DataInputStream(
    							   new BufferedInputStream(
    							   new FileInputStream(fileName)));
    			sum+=in.readInt();
    			sum+=in.readInt();
    			sum+=in.readInt();
    			System.out.println("The sum is:"+sum);
    			in.close();
    		} catch (Exception e)
    		{
    			e.printStackTrace();
    		}
    	}
    	
    	public void readMethod2()
    	{
    		try
    		{
    			FileInputStream stream=new FileInputStream("c:/kuka.dat");
    			int c;
    			while((c=stream.read())!=-1)
    			{
    				System.out.println(c);
    			}
    		} catch (Exception e)
    		{
    			e.printStackTrace();
    		}
    	}
    }
    
    本文转载自ITEYE文章: Java读写二进制文件操作
    展开全文
  • Java二进制文件读写的简单实例

    千次阅读 2019-04-22 14:27:07
    简单的Java二进制读写上手 import java.io.*; public class Test { public static void main(String[] args) throws IOException { //复制31份目标文件 for(int i=0;i<=30;i++) { File file1=new Fi...
  • java中关于二进制文件的读写[二进制文件读写]
  • CtConstructor con = new CtConstructor(new CtClass[]{pool.get("java.lang.String"),CtClass.intType},cc); con.setBody("{this.name = name;this.age = age;}"); cc.addConstructor(con); //写入到一...
  • JAVA之读取二进制文件

    万次阅读 2018-10-26 22:56:03
    目的在于:将一个二进制文件中的数据读取出来,其中数据包括点的位置信息和压力值及状态。将这些数据画作图像的形式展示。 本小程序分为以下几部分: (1)读取二进制文件;其中需要考虑二进制文件读出来的是十...
  • JAVA二进制文件读写

    2011-06-23 10:59:00
    转自:http://zoodragon.javaeye.com/blog/509237 /** * 二进制读写文件 */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; 
  • java读取文件:二进制文件 FileWriter只能接受字符串形式的参数,也就是说只能把内容存到文本文件。相对于文本文件,采用二进制格式的文件存储更省空间 InputStream用于按字节从输入流读取数据。其中...
  • 今天学习一下使用Java读写二进制文件。 先来补课: 代码如下: 1. 写二进制文件 import java.io.*; public class BinFileWrite{ public static void main(String[] args) throws Exception{ ...
  • 使用java构建的二进制文件

    千次阅读 2019-04-14 16:09:08
    @Test public void build_fixed_size_file() throws IOException { try (FileOutputStream fis = new FileOutputStream(new File("fixed_size_file_single_6"))) { byte[] bytes = {6}...
  • 这种方式得到的二进制文件会比文本文件更大,可能是二进制文件中含有类对象的其他信息 类对象需要实现Serializable接口,接口中没有需要实现的函数 测试的类class TestDataStruct implements Serializable{ String ...
  • Java二进制以及TXT文件操作 TXT文件操作 创建txt文件,并将内容写入txt文件 public static void SaveText() throws IOException{ String name="zzz"; String Myclass="软件工程"; String ID="2017211"; ...
  • RF 读写器 JAVA 接口用户手册 1....因为图片是二进制文件,则只能用字节流 File f1=new...System.out 是指标准输出,通常与计算机的接口设备有...Java 的流式输入/输出建立在四个抽象类的基础上: ......我是...
  • Java写文件的方式-二进制文件

    万次阅读 2017-12-08 11:08:45
    前言当大家面临需要持久化的数据的时候,可能会面临很多选择,比如数据库,文件等。博主这里有一个需求,有很多组数据,0-4096的整型,很显然如果使用数据库,每一组数据作为一条记录,总是感觉浪费,而且这些数据,...
  • Java Socket编程 - 基于TCP方式的二进制文件传输

    万次阅读 多人点赞 2012-12-02 13:02:26
    一个基于Java Socket协议之上文件传输的完整示例,基于TCP通信完成。 除了基于TCP的二进制...1. 基于Java Socket的二进制文件传输(包括图片,二进制文件,各种文档work,  PDF) 2. SwingWorker集合JProgressBa
  • 使用DataInputStream和DataOutputStream读写二进制文件.bin 使用PrintWriter写入文本文件请参考:https://blog.csdn.net/qq_43524683/article/details/99689599 使用Scanner和BufferedReader读取文本文件请参考:...
  • 首先在物理上文本文件和二进制文件并没有区别,都是以二进制01的形式存放于存储介质中,他们的区别只是逻辑上的区别,这两种方式只是在编码层次上有差别。文本文件是基于字符编码的文件,常见的编码有ASCII编码,...
  • 今天讲讲 前台Vue配合后台(java)导出Excel 后台返回的数据是 二进制文件流 如何将此变为 弹框下载 当时开发呢,我们后台是java 有控件 可以直接将数据导出并生成Excel文件,但是前后台传输是不可能直接传输文件的,是以...
  • 通过使用增量修补程序,可以从原始的旧二进制文件中重建(解码)二进制文件的新版本。 XDeltaEncoder使用指定的GDIFF补丁格式 XDeltaEncoder基于修改后的Javaxdelta库。 有关Javaxdelta项目的更多信息,请访问 。 ...
  • 主要介绍了Python读取二进制文件代码方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Mysql数据库的功能很强大,除了能存储字符等常见数据以外,它同样可以存储图片等二进制文件,本文以存储照片为例。 一、Mysql存储二进制文件常见报错有: 1....
  • 今天讲讲 前台Vue配合后台(java)导出Excel 后台返回的数据是 二进制文件流 如何将此变为 弹框下载 当时开发呢,我们后台是java 有控件 可以直接将数据导出并生成Excel文件,但是前后台传输是不可能直接传输文件的,是以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,954
精华内容 88,381
关键字:

java创建二进制文件

java 订阅