精华内容
下载资源
问答
  • 本篇文章主要介绍了JAVA中读取文件二进制,字符)内容的方法总结,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 记一次二进制文件的读取解析 背景 现有需求入下: c的同事将流量数据以二进制形式追加写入文件中,需要java端读取并解析,发送至kafka。 c的数据类型 Specifier Common Equivalent Signing Bits Bytes Minimum ...

    记一次二进制文件的读取解析

    背景

    现有需求入下:
    c的同事将流量数据以二进制形式追加写入文件中,需要java端读取并解析,发送至kafka。

    c的数据类型

    SpecifierCommon EquivalentSigningBitsBytesMinimum ValueMaximum Value
    int8_tsigned charSigned81-128127
    uint8_tunsigned charUnsigned810255
    int16_tshortSigned162-32,76832,767
    uint16_tunsigned shortUnsigned162065,535
    int32_tintSigned324-2,147,483,6482,147,483,647
    uint32_tunsigned intUnsigned32404,294,967,295
    int64_tlong longSigned648-9,223,372,036,854,775,8089,223,372,036,854,775,807
    uint64_tunsigned longlongUnsigned6480

    Java中的数据类型

    java是没有无符号的概念的,有时候需要特殊处理

    JAVA API的支持

    可以看一下DataInputStream类的实现

    // DataInputStream
    class DataInputStream extends FilterInputStream implements DataInput {
        /**
         * @param      b   the buffer into which the data is read.
         * @return     the total number of bytes read into the buffer, or
         *             <code>-1</code> if there is no more data because the end
         *             of the stream has been reached.
         * @exception  IOException if the first byte cannot be read for any reason
         * other than end of file, the stream has been closed and the underlying
         * input stream does not support reading after close, or another I/O
         * error occurs.
         * @see        java.io.FilterInputStream#in
         * @see        java.io.InputStream#read(byte[], int, int)
         */
        public final int read(byte b[]) throws IOException {
            return in.read(b, 0, b.length);
        }
    
        /**
         * @param      b     the buffer into which the data is read.
         * @param off the start offset in the destination array <code>b</code>
         * @param      len   the maximum number of bytes read.
         * @return     the total number of bytes read into the buffer, or
         *             <code>-1</code> if there is no more data because the end
         *             of the stream has been reached.
         * @exception  NullPointerException If <code>b</code> is <code>null</code>.
         * @exception  IndexOutOfBoundsException If <code>off</code> is negative,
         * <code>len</code> is negative, or <code>len</code> is greater than
         * <code>b.length - off</code>
         * @exception  IOException if the first byte cannot be read for any reason
         * other than end of file, the stream has been closed and the underlying
         * input stream does not support reading after close, or another I/O
         * error occurs.
         * @see        java.io.FilterInputStream#in
         * @see        java.io.InputStream#read(byte[], int, int)
         */
        public final int read(byte b[], int off, int len) throws IOException {
            return in.read(b, off, len);
        }
        
        public final void readFully(byte b[]) throws IOException {
            readFully(b, 0, b.length);
        }
    
        public final void readFully(byte b[], int off, int len) throws IOException {
            if (len < 0)
                throw new IndexOutOfBoundsException();
            int n = 0;
            while (n < len) {
                int count = in.read(b, off + n, len - n);
                if (count < 0)
                    throw new EOFException();
                n += count;
            }
        }
    
        /**
         * @param      n   the number of bytes to be skipped.
         * @return     the actual number of bytes skipped.
         * @exception  IOException  if the contained input stream does not support
         *             seek, or the stream has been closed and
         *             the contained input stream does not support
         *             reading after close, or another I/O error occurs.
         */
        public final int skipBytes(int n) throws IOException {
            int total = 0;
            int cur = 0;
    
            while ((total<n) && ((cur = (int) in.skip(n-total)) > 0)) {
                total += cur;
            }
    
            return total;
        }
    
        public final boolean readBoolean() throws IOException {
            int ch = in.read();
            if (ch < 0)
                throw new EOFException();
            return (ch != 0);
        }
        
        public final byte readByte() throws IOException {
            int ch = in.read();
            if (ch < 0)
                throw new EOFException();
            return (byte)(ch);
        }
        
        public final int readUnsignedByte() throws IOException {
            int ch = in.read();
            if (ch < 0)
                throw new EOFException();
            return ch;
        }
    
        public final short readShort() throws IOException {
            int ch1 = in.read();
            int ch2 = in.read();
            if ((ch1 | ch2) < 0)
                throw new EOFException();
            return (short)((ch1 << 8) + (ch2 << 0));
        }
    
        public final int readUnsignedShort() throws IOException {
            int ch1 = in.read();
            int ch2 = in.read();
            if ((ch1 | ch2) < 0)
                throw new EOFException();
            return (ch1 << 8) + (ch2 << 0);
        }
    
        public final char readChar() throws IOException {
            int ch1 = in.read();
            int ch2 = in.read();
            if ((ch1 | ch2) < 0)
                throw new EOFException();
            return (char)((ch1 << 8) + (ch2 << 0));
        }
    
        public final int readInt() throws IOException {
            int ch1 = in.read();
            int ch2 = in.read();
            int ch3 = in.read();
            int ch4 = in.read();
            if ((ch1 | ch2 | ch3 | ch4) < 0)
                throw new EOFException();
            return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
        }
    
        private byte readBuffer[] = new byte[8];
    
        public final long readLong() throws IOException {
            readFully(readBuffer, 0, 8);
            return (((long)readBuffer[0] << 56) +
                    ((long)(readBuffer[1] & 255) << 48) +
                    ((long)(readBuffer[2] & 255) << 40) +
                    ((long)(readBuffer[3] & 255) << 32) +
                    ((long)(readBuffer[4] & 255) << 24) +
                    ((readBuffer[5] & 255) << 16) +
                    ((readBuffer[6] & 255) <<  8) +
                    ((readBuffer[7] & 255) <<  0));
        }
    
       
        public final float readFloat() throws IOException {
            return Float.intBitsToFloat(readInt());
        }
    
        public final double readDouble() throws IOException {
            return Double.longBitsToDouble(readLong());
        }
    
        private char lineBuffer[];
    
        public final String readUTF() throws IOException {
            return readUTF(this);
        }
    }
    
    • readUnsignedByte() //从流中读取一个0~255(0xFF)的单字节数据,并以int数据类型的数据返回。返回的数据相当于C/C++语言中byte
    • int readUnsignedShort() //从流中读取一个0~65535(0xFFFF)的双字节数据,并以int数据类型的数据返回。返回的数据相当于C/C++语言中的word, 并且是以“低地址低字节”的方式返回的,不需要额外的转换。

    言归正传,开始测试

    • 对二进制文件我们使用DataInputStream读取,使用readByte()读取前50byte的结果如下:
    DataInputStream dataInputStream = new DataInputStream(new FileInputStream());
    dataInputStream.readByte();
    
    35 33 109 102 115 2 -73 96 -120 -12 3 -128 0 0 -89 -12 62 96 -62 3 99 62 0 0 -62 5 99 77 0 0 2 -52 48 100 2 0 0 0 0 0 0 0 0 0 0 0 0 -75 31 -50 
    
    • 通过与c同事的约定,文件内容为:
      6字节的头+数据内容
    • 那我们读取6字节的内容,转换一下:
    byte[] head = new byte[6];
    int headLen = dataInputStream.read(head, 0, 6);
    System.out.print(new String(head));
    
    #!!mfs
    
    • 看来取到了正确的内容,数据的格式为:
      8字节的id+4字节的时间戳+单字节的mac地址第一位+mac地址第二位+。。。
    • 那么继续向下读
    long id = Long.reverseBytes(dataInputStream.readLong());
    int timestamp = Integer.reverseBytes(dataInputStream.readInt());
    String dst_mac = String.format("%02X:%02X:%02X:%02X:%02X:%02X", 
    	dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte());
    String src_mac = String.format("%02X:%02X:%02X:%02X:%02X:%02X", 
    	dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte(), dataInputStream.readByte());
    
    • 后面重复转换就可以了
    • 那如何判断读取完毕了呢?
      起初用的是while判断
    dataInputStream.read()==-1
    

    但是流只要读过就会获取下一个字节,判断的时候已经读走一个字节的,怎么拼装数据呢。
    后来使用了dataInputStream.available()判断,当可读的数据大于0,就表示还有数据。

    • 字符串问题
      c同事写入字符串到文件时,总是指定长度,不足的位用0补足,这时候就需要对补足的0进行去除。可能你也会遇到类似的问题
    • 2字节的long怎么解析
    private static long twoBytesToLong(byte[] bytes) {
            if (bytes.length != 2) {
                return -1;
            }
            long __d = bytes[0] & 0xFF;
            __d |= (bytes[1] << 8) & 0xFFFF;
            return __d;
        }
    
    • 4字节的long怎么解析
    public static long read4BytesToLong(byte[] bytes) throws IOException {
            return Unpooled.wrappedBuffer(bytes).readUnsignedInt();
        }
    

    总结

    • 根据约定内容,进行一对一字段解析,4字节用int,8字节用long
    • 特定的java不支持的数据类型,需要特定的方法进行转换

    其他

    原码,反码,补码

    • 反码,正数的反码是自身,负数是除首位符号位取反
    • 补码,正数的补码是自身,负数是自身的反码+1
    • 补码的反码+1即原码
    //比如
    byte a = 12; //byte占8位,1字节
    
    12的二进制原码为
    00001100
    
    -12的二进制原码为
    10001100
    
    12的反码是
    00001100
    
    -12的反码是
    11110011
    
    12的补码是
    00001100
    
    -12的补码是
    11110100
    
    -12反码+1为
    10001100,即原码
    

    左移右移,有符号无符号

    计算机存储数据用的是补码,计算的任何结果都是补码,需要转换骋原码才可以进行进制换算

    有符号右移
    int a = 12;
    int b = a>>2;  // b =3
    
    int为4字节,32位
    
    a的二进制为
    00000000 00000000 00000000 00001100
    a的补码为自身
    00000000 00000000 00000000 00001100
    
    >>表示有符号右移
    即在符号位右侧添加N个0(负数添加N个1),变成
    00000000 00000000 00000000 00000011
    
    转换过来就是3
    
    int a = -12;
    int b = a >> 2; //b = -3
    
    a的二进制为
    10000000 00000000 00000000 00001100
    **转补码**
    先反码
    11111111 11111111 11111111 11110011
    再补码,反码加一
    11111111 11111111 11111111 11110100
    有符号右移2位,即除符号位,添加两个1
    111111111 11111111 11111111 11111101
    
    再反码
    10000000 00000000 00000000 00000010
    加一
    10000000 00000000 00000000 00000011
    得原码,为-3
    
    无符号右移

    和有符号右移类似,但是补全的数字,全是0

    展开全文
  • 第一步,在 axios 请求中加入参数,表示接收的数据为二进制文件流 responseType: 'blob' 第二步,在拿到数据流之后,把流转为指定文件格式并创建a标签,模拟点击下载,实现文件下载功能 let blob = res.data let reader =...
  • 通过UltraEdit查看文件编码格式可得:bgk是没有文件字符集编码格式头的,所以在可以通过下面方式大略判断。 GB2312-80编码的编码范围是高位0xa1-0xfe,低位是 0xa1-0xfe ,其中汉字范围为 0xb0a1 和 0xf7fe,...

    通过UltraEdit查看文件编码格式可得:bgk是没有文件字符集编码格式头的,所以在可以通过下面方式大略判断。

    GB2312-80编码的编码范围是高位0xa1-0xfe,低位是 0xa1-0xfe ,其中汉字范围为 0xb0a1 和 0xf7fe,如果只是简单地判断汉字,则只要查看高字节是否大于等于0xa1就可以了,还有就是,全角字符的高字节统统等于0xa3,所以很容易可以区别出全角字符来。

    通过编辑器UltraEdit整理可得:

     utf-8:对应二进制编码格式头为-17 -69 -65 十进制为:EF BB BF

     unicode:对应二进制编码格式头为-1 -2 十进制为:FF FE

     gbk格式没有自己编码头,所以无法比较.且gbk2312与gbk是包含关系

     Unicode big endian:FE、FF
      因此可以通过两种方式判断;如下:

     1、if (log[0] == -17 && log[1] == -69 && log[2] == -65)
            System.out.println(":编码为UTF-8");
       else
            System.out.println(":可能是GBK,也可能是其他编码");
            
     2、if (Integer.toHexString(0xFF & log[0]).equals("ef")
          && Integer.toHexString(0xFF & log[1]).equals("bb")
          && Integer.toHexString(0xFF & log[2]).equals("bf")) {
           System.out.println(":编码为UTF-8");
      } else {
           System.out.println(":可能是GBK,也可能是其他编码");
      }

    这里只是举例常用几种文件字符集编码格式。

    注意这个方法的局限:文件头必须有文件存储编码的信息,对于不规范的文件或被篡改过的就另当别论

    用法如下:

    /**
     * 获取二进制文件字节流中内容的编码格式
     * utf-8:对应二进制编码格式头为-17 -69 -65 十进制为:EF BB BF
     * unicode:对应二进制编码格式头为-1 -2  十进制为:FF FE
     * gbk格式没有自己编码头,所以无法比较.且gbk2312与gbk是包含关系
     */
    public static String getCodeType(byte[] b) {
        if (b[0] == -17 && b[1] == -69 && b[2] == -65) {
            return "utf8";
        } else if (b[0] == -1 && b[1] == -2) {
            return "unicode";
        } else {
            return "gbk";
        }
    }

    采用第二种方式:

    更复杂的文件编码检测,可以使用一个开源项目cpdetector,它所在的网址是:http://cpdetector.sourceforge.net/。它的类库很小,只有500K左右,cpDetector是基于统计学原理的,不保证完全正确,利用该类库判定文本文件的代码如下:

    读外部文件(先利用cpdetector检测文件的编码格式,然后用检测到的编码方式去读文件)

    还需要使用到三个第三方JAR包:antlr.jar、chardet.jar和cpdetector.jar

    可以这里下载所有全部架包:https://download.csdn.net/my  或者留言
    /** 
         * 利用第三方开源包cpdetector获取文件编码格式
         * 
         * @param path
         *            要判断文件编码格式的源文件的路径
         */
        public static String getFileEncode(String path) {
            /*
             * detector是探测器,它把探测任务交给具体的探测实现类的实例完成。
             * cpDetector内置了一些常用的探测实现类,这些探测实现类的实例可以通过add方法 加进来,如ParsingDetector、
             * JChardetFacade、ASCIIDetector、UnicodeDetector。
             * detector按照“谁最先返回非空的探测结果,就以该结果为准”的原则返回探测到的
             * 字符集编码。使用需要用到三个第三方JAR包:antlr.jar、chardet.jar和cpdetector.jar
             * cpDetector是基于统计学原理的,不保证完全正确。
             */
            CodepageDetectorProxy detector = CodepageDetectorProxy.getInstance();
            /*
             * ParsingDetector可用于检查HTML、XML等文件或字符流的编码,构造方法中的参数用于
             * 指示是否显示探测过程的详细信息,为false不显示。
             */
            detector.add(new ParsingDetector(false));
            /*
             * JChardetFacade封装了由Mozilla组织提供的JChardet,它可以完成大多数文件的编码
             * 测定。所以,一般有了这个探测器就可满足大多数项目的要求,如果你还不放心,可以
             * 再多加几个探测器,比如下面的ASCIIDetector、UnicodeDetector等。
             */
            detector.add(JChardetFacade.getInstance());// 用到antlr.jar、chardet.jar
            // ASCIIDetector用于ASCII编码测定
            detector.add(ASCIIDetector.getInstance());
            // UnicodeDetector用于Unicode家族编码的测定
            detector.add(UnicodeDetector.getInstance());
            java.nio.charset.Charset charset = null;
            File f = new File(path);
            try {
                charset = detector.detectCodepage(f.toURI().toURL());
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            if (charset != null)
                return charset.name();
            else
                return null;
        }
        String charsetName = getFileEncode(configFilePath);
        System.out.println(charsetName);
        inputStream = new FileInputStream(configFile);
        BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, charsetName));
    读jar包内部资源文件(先利用cpdetector检测jar内部的资源文件的编码格式,然后以检测到的编码方式去读文件):


    /**
         * 利用第三方开源包cpdetector获取URL对应的文件编码
         * 
         * @param path
         *            要判断文件编码格式的源文件的URL
         */
        public static String getFileEncode(URL url) {
            /*
             * detector是探测器,它把探测任务交给具体的探测实现类的实例完成。
             * cpDetector内置了一些常用的探测实现类,这些探测实现类的实例可以通过add方法 加进来,如ParsingDetector、
             * JChardetFacade、ASCIIDetector、UnicodeDetector。
             * detector按照“谁最先返回非空的探测结果,就以该结果为准”的原则返回探测到的
             * 字符集编码。使用需要用到三个第三方JAR包:antlr.jar、chardet.jar和cpdetector.jar
             * cpDetector是基于统计学原理的,不保证完全正确。
             */
            CodepageDetectorProxy detector = CodepageDetectorProxy.getInstance();
            /*
             * ParsingDetector可用于检查HTML、XML等文件或字符流的编码,构造方法中的参数用于
             * 指示是否显示探测过程的详细信息,为false不显示。
             */
            detector.add(new ParsingDetector(false));
            /*
             * JChardetFacade封装了由Mozilla组织提供的JChardet,它可以完成大多数文件的编码
             * 测定。所以,一般有了这个探测器就可满足大多数项目的要求,如果你还不放心,可以
             * 再多加几个探测器,比如下面的ASCIIDetector、UnicodeDetector等。
             */
            detector.add(JChardetFacade.getInstance());// 用到antlr.jar、chardet.jar
            // ASCIIDetector用于ASCII编码测定
            detector.add(ASCIIDetector.getInstance());
            // UnicodeDetector用于Unicode家族编码的测定
            detector.add(UnicodeDetector.getInstance());
            java.nio.charset.Charset charset = null;
            try {
                charset = detector.detectCodepage(url);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            if (charset != null)
                return charset.name();
            else
                return null;
        }
        URL url = CreateStationTreeModel.class.getResource("/resource/" + "配置文件");
        URLConnection urlConnection = url.openConnection();
        inputStream=urlConnection.getInputStream();
        String charsetName = getFileEncode(url);
        System.out.println(charsetName);
        BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, charsetName));

    3:探测任意输入的文本流的编码,方法是调用其重载形式:


    charset=detector.detectCodepage(待测的文本输入流,测量该流所需的读入字节数);

    上面的字节数由程序员指定,字节数越多,判定越准确,当然时间也花得越长。要注意,字节数的指定不能超过文本流的最大长度。

    4:判定文件编码的具体应用举例:
        属性文件(.properties)是Java程序中的常用文本存储方式,象STRUTS框架就是利用属性文件存储程序中的字符串资源。它的内容如下所示:
        #注释语句
        属性名=属性值
        读入属性文件的一般方法是:
    FileInputStream ios=new FileInputStream(“属性文件名”);
    Properties prop=new Properties();
    prop.load(ios);
    String value=prop.getProperty(“属性名”);
    ios.close();

        利用java.io.Properties的load方法读入属性文件虽然方便,但如果属性文件中有中文,在读入之后就会发现出现乱码现象。发生这个原因是load方法使用字节流读入文本,在读入后需要将字节流编码成为字符串,而它使用的编码是“iso-8859-1”,这个字符集是ASCII码字符集,不支持中文编码,
        方法一:使用显式的转码:
    String value=prop.getProperty(“属性名”);
    String encValue=new String(value.getBytes(“iso-8859-1″),”属性文件的实际编码”);

        方法二:象这种属性文件是项目内部的,我们可以控制属性文件的编码格式,比如约定采用Windows内定的GBK,就直接利用”gbk”来转码,     如果约定采用UTF-8,就使用”UTF-8″直接转码。
        方法三:如果想灵活一些,做到自动探测编码,就可利用上面介绍的方法测定属性文件的编码,从而方便开发人员的工作
        补充:可以用下面代码获得Java支持编码集合:
        Charset.availableCharsets().keySet();
        可以用下面的代码获得系统默认编码:
        Charset.defaultCharset();
     

    参考:https://blog.csdn.net/servermanage/article/details/8595676

    https://blog.csdn.net/shuijianbaozi/article/details/79457723

    展开全文
  • 前面的博客中我们讲到了检测,新建,读取文件修改时间、大小和内容,并向指定文件写入指定内容和文本文件行读取并显示字节和字符数。 这里我们学习二进制流对任何文件进行复制,并对文本和图片做一个例子。 二、...

    一、前言

    本次学习应用于文件操作方面,前面我们说到实现文本的不同处理方式,本次目的是为了实现各种文件的复制操作

    前面的博客中我们讲到了检测,新建,读取文件修改时间、大小和内容,并向指定文件写入指定内容文本文件行读取并显示字节和字符数

    这里我们学习二进制流对任何文件进行复制,并对文本图片做一个例子。

    二、任务学习

    任务要求:

    • 通过二进制流的操作方式把程序调整为可以实现对任何类型文件进行文件复制
    • 不调用windows命令行的内部命令copy

    1)分析学习:

    1.1 判断目的地址的父类目录是否存在

    2
    当直接使用file.createNewFile;方法时,如果父目录不存在,程序将会抛异常
    这个方法是在必须父目录存在的情况下创建文件的,只能创建文件,不能创建文件夹,父目录不存在时是需要抛出一个异常的。
    所以我们可以先检测父类目录是否存在,然后再进行后面的操作。

    1.2 在目的地址创建指定的父类目录

    在这里插入图片描述
    为什么用mkdirs()呢?
    因为这个方法可以在不知道有没有父类文件夹的情况下,创建文件夹。
    mkdir()必须在有父类文件夹的情况下创建文件。

    • 区别见下图:
    boolean mkdir()boolean mkdirs()
    功能:创建子目录功能:创建多级目录
    创建此抽象路径名指定的目录创建此抽象路径名指定的目录,包括所有必需但不存在的父目录
    当父目录存在时返回true;不存在时返回false当父目录不存在时,mkdirs会创建父目录返回true
    1.3 在指定目的地址创建文件

    1
    此方法会检查文件是否存在,若不存在则创建该文件。

    2)程序代码:

    /* 项目名称:Task_Du
     * 创建时间:2019年4月2日
     * 创建者:Administrator_wz
     * 创建地点:kmust
     * 功能:二进制流对任何文件进行复制
     */
     import java.io.*;//导入java.io包中的所有类
     import java.io.FileReader;//导入java.io包中的FileReader类
     import java.util.Scanner;//导入java.util包中的Scanner类
     import java.util.Date;//导入java.util包中的Date类
     public class file6{//创建类名
    	public static void main(String[] args)throws IOException{//程序的主函数入口
    		try{//用try-catch语句将逻辑语句包起来,并读取指定的文件
    			//输入将要复制文件的源地址
    			Scanner s1 = new Scanner(System.in);//获取键盘输入并赋值给s1字符串
            	System.out.println("请输入想要复制的源地址:");//输入提示信息
            	String a = s1.nextLine();//定义字符串变量,并赋值为用户输入的信息
    			File file1 = new File(a);//定义待复制文件源地址
    			//输入将要复制文件的目的地址
    			Scanner s2 = new Scanner(System.in);//获取键盘输入并赋值给s2字符串
    			System.out.println("请输入想要复制的目的地址:");//输入提示信息
    			String b = s2.nextLine();//定义字符串变量,并赋值为用户输入的信息
    			File file2 =new File(b);;//创建待复制文件目的地址
    			file2.getParentFile().mkdirs();//创建父级文件路径
    			file2.createNewFile();//创建文件
    			System.out.println(file2.exists());//输出布尔信息
    			FileInputStream c=new FileInputStream(file1);//定义FileInputStream对象
    			FileOutputStream d=new FileOutputStream(file2);//定义FileOutputStream对象			
    			byte[] date=new byte[1024];//定义一个byte数组
    			int i=0;//定义一个变量
    			while((i=c.read(date))>0){//判断有没有读取到文件末尾
    				d.write(date);//写数据
    			}
    			c.close();//关闭流
    			d.close();//关闭流
    			System.out.println("源文件已经复制到目的地址!");//输出提示信息
    			System.out.println("该文件最后的修改时间是:"+new Date(file2.lastModified()));//输出文件的修改时间
    		}catch(Exception e){//当代码异常时用catch捕获异常
    			e.printStackTrace();//打印异常
    		}	
    	} 	 
     }
    

    3)执行结果

    3.1 以文本文件为例

    1

    2
    3

    3.2 以图片文件为例

    1
    2
    3


    参考链接:
    https://blog.csdn.net/Atishoo_13/article/details/82717669
    https://blog.csdn.net/linglongxin24/article/details/52836111
    https://blog.csdn.net/qq_40612528/article/details/85074438
    https://blog.csdn.net/tingzhiyi/article/details/52024240
    https://blog.csdn.net/summoxj/article/details/80774224
    https://blog.csdn.net/Mrchongyang/article/details/82850522#commentsedit
    https://blog.csdn.net/weixin_42014622/article/details/82959678
    https://www.cnblogs.com/Darkqueen/p/9024274.html
    https://blog.csdn.net/mingzhuo_126/article/details/83549000
    https://blog.csdn.net/qq_24521431/article/details/81383346
    http://www.cnblogs.com/xiaoyao-001/p/9308561.html


    展开全文
  • HTTP 请求工具类(含HTTPS)(参数、二进制流、文件、图片)
  • java中PDF与二进制数据互相转换

    千次阅读 2020-05-13 22:03:31
    PDF与二进制数据互相转换 import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; ...

    PDF与二进制数据互相转换
    亲测可用!!!

    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.ByteArrayInputStream;    
    import java.io.ByteArrayOutputStream;    
    import java.io.File;    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;    
    
    
    import sun.misc.BASE64Decoder;    
    import sun.misc.BASE64Encoder;    
    /***
     * @author lqx
     * 为WEBSERVICE 准备 PDF的二进制流的字符串
     * 文件在 XXX转成二进制流的字符串,及将二进制流反转成PDF\PDFBinary.jar
     * xxx转成二进制流的字符串,及将二进制流反转成PDF\PDFBinary.jar
     */
    public class PDFBinaryUtil {    
        /*BASE64Encoder和BASE64Decoder这两个方法是sun公司的内部方法,并没有在java api中公开过,所以使用这些方法是不安全的,
         * 将来随时可能会从中去除,所以相应的应该使用替代的对象及方法,建议使用apache公司的API---可引用 import org.apache.commons.codec.binary.Base64;进行替换*/
      static BASE64Encoder encoder = new sun.misc.BASE64Encoder();    
      static BASE64Decoder decoder = new sun.misc.BASE64Decoder();    
          
      public static void main(String[] args) {    
           //将PDF格式文件转成base64编码 
           String base64String = getPDFBinary("C:\\Users\\Pluto\\Desktop\\1.1命题与联结词(第2课时).pdf");
           System.out.println(base64String);
          //将base64的编码转成PDF格式文件,,保存到XXX
          base64StringToPDF(base64String,"C:\\Users\\Pluto\\Desktop\\2.pdf");
      }    
          
      /**
       *  将PDF转换成base64编码
       *  1.使用BufferedInputStream和FileInputStream从File指定的文件中读取内容;
       *  2.然后建立写入到ByteArrayOutputStream底层输出流对象的缓冲输出流BufferedOutputStream
       *  3.底层输出流转换成字节数组,然后由BASE64Encoder的对象对流进行编码
       * */
      public static String getPDFBinary(String filePath) {
          FileInputStream fin =null;
          BufferedInputStream bin =null;
          ByteArrayOutputStream baos = null;
          BufferedOutputStream bout =null;
          try {
              //建立读取文件的文件输出流
              fin = new FileInputStream(new File(filePath));
              //在文件输出流上安装节点流(更大效率读取)
              bin = new BufferedInputStream(fin);
              // 创建一个新的 byte 数组输出流,它具有指定大小的缓冲区容量
              baos = new ByteArrayOutputStream();
              //创建一个新的缓冲输出流,以将数据写入指定的底层输出流
              bout = new BufferedOutputStream(baos);
              byte[] buffer = new byte[1024];
              int len = bin.read(buffer);
              while(len != -1){
                  bout.write(buffer, 0, len);
                  len = bin.read(buffer);
              }
              //刷新此输出流并强制写出所有缓冲的输出字节,必须这行代码,否则有可能有问题
              bout.flush();
               byte[] bytes = baos.toByteArray();
               //sun公司的API
               return encoder.encodeBuffer(bytes).trim();  
               //apache公司的API
               //return Base64.encodeBase64String(bytes);
              
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    fin.close();
                    bin.close();
                    //关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用,而不会产生任何 IOException
                    //baos.close();
                    bout.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
          return null;
      }
          
      /**
       * 将base64编码转换成PDF,保存到
       * @param base64sString
       * 1.使用BASE64Decoder对编码的字符串解码成字节数组
       *  2.使用底层输入流ByteArrayInputStream对象从字节数组中获取数据;
       *  3.建立从底层输入流中读取数据的BufferedInputStream缓冲输出流对象;
       *  4.使用BufferedOutputStream和FileOutputSteam输出数据到指定的文件中
       */
      public static void base64StringToPDF(String base64sString,String filePath){
          BufferedInputStream bin = null;
          FileOutputStream fout = null;
          BufferedOutputStream bout = null;
          try {
               //将base64编码的字符串解码成字节数组
                byte[] bytes = decoder.decodeBuffer(base64sString);
              //apache公司的API
              //byte[] bytes = Base64.decodeBase64(base64sString);
                //创建一个将bytes作为其缓冲区的ByteArrayInputStream对象
                ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
                //创建从底层输入流中读取数据的缓冲输入流对象
                bin = new BufferedInputStream(bais);
                //指定输出的文件
                File file = new File(filePath);
                //创建到指定文件的输出流
                fout  = new FileOutputStream(file);
                //为文件输出流对接缓冲输出流对象
                bout = new BufferedOutputStream(fout);
                
                byte[] buffers = new byte[1024];
                int len = bin.read(buffers);
                while(len != -1){
                    bout.write(buffers, 0, len);
                    len = bin.read(buffers);
                }
                //刷新此输出流并强制写出所有缓冲的输出字节,必须这行代码,否则有可能有问题
                bout.flush();
                
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    bin.close();
                    fout.close();
                    bout.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
      }
    }
    

    对原代码略做修改
    原博文地址

    展开全文
  • java中的IO流(1)----读取二进制文件

    万次阅读 2015-06-07 20:27:09
    利用jvaa读取文本文件
  • ByteToFileUtil(将二进制流转换为文件的工具类): package com.*.utils; import java.io.*; public class ByteToFileUtil { /** * 获得指定文件的byte数组 */ private byte[] getBytes(String filePath){ ...
  • c++读写二进制文件 python读写文本文件 python读写二进制文件 np.save & np.load 将数组以未压缩的原始二进制格式保存在扩展名为 npy 的文件中 np.save('name.npy', data) data = np.load('name.npy') to...
  • 关于读取二进制文件 read() 读取指定字节数的问题 遇到的问题 ​ 今天在写组件的时候遇到的读取指定字节数的二进制文件,并且要求如果要求重复读取,则要从文件中从头开始读取。 问题分析 ​ 对于读取二进制文件,...
  • 前面的博客中我们讲到了检测,新建,读取文件修改时间、大小和内容,并向指定文件写入指定内容、文本文件行读取并显示字节和字符数和使用二进制流对任何文件进行复制。 这里我们学习二进制流对任何文件进行移动,...
  • 一、查看文件二进制码     想查看一个文件二进制码有很多工具可以用HEX的方式读文件,例如:Notepad++、UltraEdit、HexViewer等等。 Notepad++的HEX-Editor:   二、DIY浏览器 1.初步实现的浏览功能: ...
  • 使用Spark读取并分析二进制文件

    千次阅读 2019-09-06 09:47:44
    需求 客户希望通过spark来分析二进制文件中0和1的数量以及占比。如果要分析的是目录,则针对目录下的每个...可以在linux下查看二进制文件内容。命令: xxd –b –c 1 filename -c 1是显示1列1个字符,-b是显...
  • 上传 public AjaxResult up(MultipartFile file) throws Exception { if (null == file) { return AjaxResult.error("文件为空"); } byte[] imgbytes = file.getBytes(); String filename = f...
  • :就是二进制数据,比如通过new Blob()创建的对象就是Blob对象,又比如在XMLHttpRequest里,如果指定responseType为blob,那么得到的返回值也是一个blob对象。  注意点:每次调用createObjectURL的时候,一个新...
  • 右键项目-》属性-》java bulid path-》jre System Library-》access rules-》resolution选择accessible,下面填上** 点击确定即可!!! 转载于:https://www.cnblogs.com/xinzheng/p/8422679.html
  • } /** * 获取图片类型 * @param data * @return */ public static ImageType getImageType(byte[] data) { // Png: if (PNG.getBegin() == data[1] && PNG.getMid() == data[2] && PNG.getEnd() == data[3...
  • //允许使用过时的函数和不安全的函数,去掉警告 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> ...//内容一:读取文件(文本文件) /* int main(){ char file_path[] = "C:\\Users\...
  • Qt 学习 之 二进制文件读写

    万次阅读 2015-06-11 16:59:26
    同时,Qt 还提供了更高一级的操作:用于二进制的流QDataStream和用于文本流的QTextStream。本节,我们将讲解有关QDataStream的使用以及一些技巧。下一章则是QTextStream的相关内容。QDataStream提供了基于Q
  • 二进制文件和字节流

    千次阅读 2019-02-24 16:40:34
    本节我们介绍在Java中如何以二进制字节的方式来处理文件,上节我们提到Java中有流的概念,以二进制方式读写的主要流有: InputStream/OutputStream: 这是基类,它们是抽象类。 FileInputStream/FileOutputStream: ...
  • 文件中按照GBK编码方式读取二进制流,将二进制数据封装到XML数据包中,经过 网络传输到另一端后,再将二进制数据按照GBK编码写回到某一文件中,二进制数据 能够获取到,但是经过字符串处理后,到另一端如何还原...
  • 字节流实现复制图片(二进制文件)字节缓冲流实现复制图片(二进制文件)字符流实现复制文本字符缓冲流实现复制文本 流是什么? 在 Java中所有数据都是使用流读写的。流是一组有顺序的,有起点和终点的字节集合,是对...
  • python打包的二进制文件反编译

    千次阅读 2020-07-06 22:51:00
    所以官方就提供了一些打包程序,将代码与解释环境打包到二进制文件中,方便在各种操作系统中运行。 下面为一些文件格式: .py: Python代码文件。对于一些开源项目,发布方也许会直接提供源码,但是使用时需...
  • java 获得指定文件的byte数组 ,根据byte数组,生成文件
  • Qt之文件详解(二)二进制文件读写

    千次阅读 2017-02-08 14:48:36
    同时,Qt 还提供了更高一级的操作:用于二进制的流QDataStream和用于文本流的QTextStream。本节,我们将讲解有关QDataStream的使用以及一些技巧。下一章则是QTextStream的相关内容。 QDataStream提
  • 一个基于Java Socket协议之上文件传输的完整示例,基于TCP通信完成。 除了基于TCP的二进制文件传输,还演示了JAVA...基于Java Socket的二进制文件传输(包括图片,二进制文件,各种文档work, PDF) 2.SwingWorker集合...
  • 1、数据库存储二进制流使用的数据类型为BLOB 2、mybatis语句 二进制流存入数据库 <update id="saveKeyValue" parameterType="java.util.Map" statementType="PREPARED"> update license set keyValue=...
  • maven打包二进制文件

    2016-09-18 13:48:00
    java做数据挖掘的时候,保存一个模型文件java序列化成一个对象文件,在用maven打包的时候遇到些问题. 一是做个记录,是可以帮助大家少走些弯路. 一.找不到文件  maven打包路径问题,首先遇到的问题就是,打包后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,718
精华内容 56,687
关键字:

java获取二进制文件指定页的内容

java 订阅