Java IO流详细教程

最新推荐文章于 2024-08-23 14:41:40 发布
最新推荐文章于 2024-08-23 14:41:40 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qi341500/article/details/130938030
版权

目录

一、IO介绍

IO流体系

字节流

字节输出流：FileoutputStream

字节输入流FilelnputStream

字符流

字符输入流

字符输出流

缓冲流

字节缓冲流

字符缓冲流

序列化、反序列化流

序列化/对象操作输出流

反序列化/对象操作输入流

打印流

字节打印流

字符打印流

解压缩流

解压流

压缩流

IO流工具

一、IO介绍

Java IO流是Java中处理输入输出的机制。它是一种数据传输方式，用于在程序和外部设备（例如文件、网络连接、控制台）之间传输数据。Java IO流提供了一种灵活的方式来读取和写入数据，可以处理各种类型的数据，包括文本、二进制和对象数据。Java IO流包括输入流和输出流两种类型，其中输入流用于读取数据，输出流用于写入数据。在Java中，IO流是通过类和接口来实现的。

Java IO流提供了多种类型的流，包括字节流和字符流。字节流处理的是二进制数据，可以操作所有类型的文件，而字符流处理的是文本数据，只能操作纯文本文件（纯文本文件指：用windows系统自带的记事本打开并且能读懂的文件，例如：txt文件，md文件，xml文件，lrc文件等
）。字节流包括InputStream和OutputStream，而字符流包括Reader和Writer。此外，Java IO流还提供了缓冲流、数据流、对象流等类型的流，以便更方便地处理数据。

IO流体系

字节流

字节输出流：FileoutputStream

操作本地文件的字节输出流，可以把程序中的数据写到本地文件中。

书写步骤：

1、创建字节输出流对象

2、写数据

3、释放资源

        File f1 = new File( "D:\\a.txt" );
        boolean b1 = false;
        FileOutputStream fos = null;
        try {
            //在D盘创建文件
            b1 = f1.createNewFile();
            //创建输出流对象，数据传输通道
            fos = new FileOutputStream("D:\\a.txt" );
            //写入数据
            fos.write(97);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(b1);

细节1:参数是字符串表示的路径或者是File对象都是可以的

        FileOutputStream fos = null;
        try {
            //创建输出流对象，数据传输通道
            fos = new FileOutputStream(new File( "D:\\a.txt" ) );
            //写入数据
            fos.write(97);
           
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


细节2:如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。

细节3:如果文件已经存在，则会清空文件
细节: write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符

FileOutputStream写数据的3种方式

方法名称说明
void write(int b)一次写一个字节数据
void write(byte[ ] b)一次写一个字节数组数据
void write(byte[ ] b, int off， int len)一次写一个字节数组的部分数据

 方式一：

 public static void main(String[] args) {
         FileOutputStream fos = null;
        try {
            //创建输出流对象，数据传输通道
            fos = new FileOutputStream(new File( "D:\\aa\\a.txt" ) );
            //写入数据
            fos.write(97);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

方式二：

public static void main(String[] args) {
         FileOutputStream fos = null;
        try {
            //创建输出流对象，数据传输通道
            fos = new FileOutputStream(new File( "D:\\a.txt" ) );
            byte[] bytes = {97, 98, 99, 100};
            //写入数据
            fos.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

方式三：

public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //创建输出流对象，数据传输通道
            fos = new FileOutputStream(new File( "D:\\a.txt" ) );
            byte[] bytes = {97, 98, 99, 100};
            //写入数据
            //参数一：数组    参数二：起始索引    参数三：写入的个数
            //b c
            fos.write(bytes,1,2);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

换行写入：

public static void main(String[] args) {
            FileOutputStream fos = null;
        try {
            //创建输出流对象，数据传输通道
            fos = new FileOutputStream(new File( "D:\\a.txt" ) );
            String str = "zhangsan";
            byte[] bytes1 = str.getBytes();
            fos.write(bytes1);

            String str2 = "\r\n";
            byte[] bytes2 = str2.getBytes();
            fos.write(bytes2);

            String str3 = "666";
            byte[] byte3 = str3.getBytes();
            fos.write(byte3);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

续写：

 public static void main(String[] args) {
         FileOutputStream fos = null;
        try {
            //创建输出流对象，数据传输通道
            //参数1：文件1路径     参数2：续写开关，ture续写，false文件清空从新写入
            fos = new FileOutputStream(new File( "D:\\a.txt" ),true);
            String str = "zhangsan";
            byte[] bytes1 = str.getBytes();
            fos.write(bytes1);

            String str2 = "\r\n";
            byte[] bytes2 = str2.getBytes();
            fos.write(bytes2);

            String str3 = "666";
            byte[] byte3 = str3.getBytes();
            fos.write(byte3);
           
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

字节输入流FilelnputStream

操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来。
书写步骤：

1、创建字节输入流对象

2、读数据

3、释放资源

 public static void main(String[] args) {
         FileInputStream fis = null;
        try {
            //创建输入流对象，数据传输通道
            fis = new FileInputStream("D:\\a.txt" );
            //读取数据
            int read = fis.read();
            System.out.println((char) read);
           
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

细节1：如果文件不存在，就直接报错。
细节2：读取数据，一次读一个字节，读出来的是数据在ASCII上对应的数字细节，读到文件末尾了, read方法返回 -1。

循环读取文件

public static void main(String[] args) {
         FileInputStream fis = null;
        try {
            //创建输入流对象，数据传输通道
            fis = new FileInputStream("D:\\a.txt" );
            //读取数据
            int b;
            while ((b = fis.read()) != -1){
                System.out.print((char) b);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

拷贝文件

public static void main(String[] args) {
         FileInputStream fis = null;
         FileOutputStream fos = null;
        try {
            //创建输入流对象，数据传输通道
            fis = new FileInputStream("D:\\a.txt" );
            //创建输出流对象，数据传输通道
            fos = new FileOutputStream("D:\\b.txt");
            //读取数据,边读编写
            int b;
            while ((b = fis.read()) != -1){
                fos.write(b);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

一次读取多个字节数据

public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            //创建输入流对象，数据传输通道
            fis = new FileInputStream("D:\\a.txt" );
            byte[] bytes = new byte[2];
            //读取数据,返回读取元素的个数
            int len = fis.read(bytes);
            System.out.println(len);
            //从当前数组中，从第0个元素开始，读取len个元素
            String str = new String(bytes,0,len);
            System.out.println(str);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

字符流

字符流是Java IO流中的一种，用于处理文本数据。与字节流不同，字符流是面向字符的，可以处理Unicode字符集中的字符。Java中的字符流主要有两个类：Reader和Writer。

Reader类是抽象类，它提供了多种方法用于读取字符数据。常用的子类包括FileReader、InputStreamReader、CharArrayReader等。其中，FileReader用于读取文件中的字符数据，InputStreamReader用于读取字节流并将其转换为字符流，CharArrayReader用于读取字符数组中的数据。

Writer类也是抽象类，它提供了多种方法用于写入字符数据。常用的子类包括FileWriter、OutputStreamWriter、CharArrayWriter等。其中，FileWriter用于向文件中写入字符数据，OutputStreamWriter用于将字符流转换为字节流并写入输出流，CharArrayWriter用于向字符数组中写入数据。

与字节流不同，字符流可以自动处理字符集编码和解码的问题，因此在处理文本数据时更加方便和安全。同时，字符流也提供了缓冲区和转换器等功能，可以提高数据传输的效率。

总之，字符流是Java IO流中的一种，用于处理文本数据。它具有自动处理字符集编码和解码的功能，提供了缓冲区和转换器等功能，是处理文本数据的首选。

特点：

输入流：一次读一个字节，遇到中文时，一次读多个字节

输出流：底层会把数据按照指定的编码方式进行编码，变成字节再写到文件中

字符输入流

书写步骤：

1、创建字符输入流对象

2、读取数据

3、释放资源

public static void main(String[] args) throws IOException {
        /*
        第一步:创建对象
        public FileReader(File file)        创建字符输入流关联本地文件
        public FileReader(String pathname)  创建字符输入流关联本地文件

        第二步:读取数据
        public int read()                   读取数据，读到末尾返回-1
        public int read(char[] buffer)      读取多个数据，读到末尾返回-1

        第三步:释放资源
        public void close( )              释放资源/关流
        */

        FileReader fr = new FileReader("D:\\a.txt");

        int ch;
        while ((ch = fr.read()) != -1){
            System.out.print((char) ch);
        }
        fr.close();
    }

read (）细节:
1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个

2.在读取之后，方法的底层还会进行解码并转成十进制。最终把这个十进制作为返回值

一次读取多个字符

 public static void main(String[] args) throws IOException {
        /*
        第一步:创建对象
        public FileReader(File file)        创建字符输入流关联本地文件
        public FileReader(String pathname)  创建字符输入流关联本地文件

        第二步:读取数据
        public int read()                   读取数据，读到末尾返回-1
        public int read(char[] buffer)      读取多个数据，读到末尾返回-1

        第三步:释放资源
        public void close( )              释放资源/关流
        */

        FileReader fr = new FileReader("D:\\a.txt");
        char[] chars = new char[2];
        int len;
        //read(chars):读取数据，解码，强转三步合并了，把强转之后的字符放到数组当中
        //相当于空参的read +强转类型转换
        while ((len = fr.read(chars)) != -1){
            System.out.print(new String(chars,0,len));
        }
        fr.close();
    }

字符输出流

构造方法说明
public Filewriter(File file)创建字符输出流关联本地文件
public Filewriter( string pathname)创建字符输出流关联本地文件
public Filewriter(File file, boolean append)创建字符输出流关联本地文件，续写
public Filewriter(string pathname,boolean append)创建字符输出流关联本地文件，续写

成员方法

成员方法说明
void write(int c)写出一个字符
void write(string str)写出一个字符串
void write(String str， int off， int len)写出一个字符串的一部分
void write(char[ ] cbuf)写出一个字符数组
void write(char[ ] cbuf, int off, int len)写出字符数组的一部分

书写步骤：

1、创建字符输出流对象

2、写入数据

3、释放资源

 public static void main(String[] args) throws IOException {
        //创建字符输出流对象
        FileWriter fw = new FileWriter("D:\\a.txt");

        //void write(int c)	写出一个字符
        fw.write(97);
        //void write(string str)	写出一个字符串
        fw.write("你好张三");
        //void write(String str， int off， int len)	写出一个字符串的一部分
        fw.write("你好张三",2,2);
        //void write(char[ ] cbuf)	写出一个字符数组
        char[] chars = {'1','2','3','你'};
        fw.write(chars);
        //void write(char[ ] cbuf, int off, int len)	写出字符数组的一部分
        fw.write(chars,2,2);
        fw.close();
    }

细节1：参数是字符串表示的路径或者File对象都是可以的
细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的

细节3：如果文件已经存在，则会清空文件，如果不想清空可以打开续写开关
细节4：如果write方法的参数是整数，但是实际上写到本地文件中的是整数在字符集上对应的字符

字符流原理解析
创建字符输入流对象：

底层：关联文件，并创建缓冲区（长度为8192的字节数组)

读取数据：

1.判断缓冲区中是否有数据可以读取

2.缓冲区没有数据:就从文件中获取数据，装到缓冲区中，每次尽可能装满缓冲区如果文件中也没有数据了，返回-1

3.缓冲区有数据:就从缓冲区中读取。
空参的read方法:一次读取一个字节，遇到中文一次读多个字节，把字节解码并转成十进制返回

有参的read方法:把读取字节，解码，强转三步合并了，强转之后的字符放到数组中

拷贝文件夹，带子文件夹

 public static void main(String[] args) throws IOException {
        //拷贝一个文件夹
        //创建对象表示数据源
        File src = new File("D:\\aaa\\src");
        //创建对象表示拷贝目的地
        File temp = new File("D:\\aaa\\temp");
        //掉方法
        copyFile(src,temp);
    }

    /**
     * 拷贝文件
     * @param src 数据源
     * @param temp 目的地
     */
    private static void copyFile(File src, File temp) throws IOException {
        //创建文件夹
        temp.mkdirs();
        //递归
        //进入数据源
        File[] files = src.listFiles();
        //遍历数组
        for (File file : files) {
            if (file.isFile()){
                //拷贝文件
                FileInputStream fis = new FileInputStream(file);
                FileOutputStream fos = new FileOutputStream(new File(temp,file.getName()));
                byte[] bytes = new byte[1024];
                int len;
                while ((len = fis.read(bytes)) != -1){
                    fos.write(bytes,0,len);
                }
                fos.close();
                fis.close();
            }else {
                //文件夹递归
                //new File(temp,file.getName()) 创建文件夹，名字file.getName()
                copyFile(file,new File(temp,file.getName()));
            }
        }
    }

缓冲流

缓冲流（Buffered Stream）是一种流式输入输出（I/O）操作的方式。通常，缓冲流会在内存中创建一个缓冲区，将数据暂时存放在缓冲区中，然后再一次性地将缓冲区中的数据写入到文件或者网络中，或者从文件或者网络中读取一定量的数据到缓冲区中，再从缓冲区中读取数据。

缓冲流的作用是提高I/O操作的效率。因为在进行I/O操作时，每次读写一个字节或者一个字符都会涉及到磁盘或者网络的访问，这样会导致I/O操作的效率非常低下。而缓冲流的使用可以将多个I/O操作合并为一次操作，从而提高I/O操作的效率。

Java中的缓冲流有两种：BufferedInputStream和BufferedOutputStream。其中，BufferedInputStream是InputStream的子类，可以提高从输入流中读取数据的效率；BufferedOutputStream是OutputStream的子类，可以提高向输出流中写入数据的效率。在使用缓冲流时，需要注意及时关闭流，避免资源泄露和数据丢失

字节缓冲流

 字节缓冲流拷贝文件

public static void main(String[] args) throws IOException {
        //创建缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\b.txt"));
        //循环读取文件
        int len;
        while ((len = bis.read()) != -1){
            bos.write(len);
        }
        //释放资源
        bos.close();
        bis.close();
    }

一次读取多个字节

public static void main(String[] args) throws IOException {
        //创建缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\b.txt"));
  byte[] bytes = new byte[1024];
        //循环读取文件
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }
        //释放资源
        bos.close();
        bis.close();
    }

字符缓冲流

 字符缓冲输入流特有方法说明
public string readLine()读取一行数据，如果没有数据可读了，会返回null
字符缓冲输出流特有方法说明
public void newLine()跨平台的换行

字符缓冲输入流

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("D:\\a.txt"));
        //读取数据,一次读一行
        String line = br.readLine();
        System.out.println(line);
        br.close();
    }

字符缓冲输出流

 public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\a.txt"));
        //写入数据
        bw.write("123");
        //写入换行
        bw.newLine();
        bw.write("456");

        bw.close();
    }

序列化、反序列化流

Java中的序列化和反序列化可以使用ObjectOutputStream和ObjectInputStream来实现。ObjectOutputStream是OutputStream的子类，可以将对象序列化为字节流并写入到输出流中；ObjectInputStream是InputStream的子类，可以从输入流中读取字节流并反序列化为对象。

序列化和反序列化的作用是在网络传输或者持久化存储时，将对象转换为字节流进行传输或者存储，以便在需要时重新恢复对象。

序列化/对象操作输出流

构造方法说明
public objectoutputstream(outputstream out)把基本流包装成高级流
成员方法说明
public final void writeobject(object obj)把对象序列化(写出）到文件中去

注意：

  1. 序列化的对象必须实现Serializable接口，否则会抛出NotSerializableException异常。

  2. 序列化的对象中的属性也必须是可序列化的，否则也会抛出NotSerializableException异常。

  3. 序列化和反序列化的流必须在同一个JVM中，否则会抛出ClassNotFoundException异常。

  4. 序列化和反序列化的流必须及时关闭，避免资源泄露。

  5. 序列化和反序列化的过程中，可能会出现版本不兼容的问题，需要使用serialVersionUID来解决。

public static void main(String[] args) throws IOException {
        //创建对象
        Student student = new Student("张三",20);
        //创建序列化流对象/对象操作输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));
        //写入数据
        oos.writeObject(student);
        //释放资源
        oos.close();
    }

反序列化/对象操作输入流

可以把序列化到本地文件中的对象读取到程序中

构造方法说明
public objectInputstream( Inputstream out)把基本流变成高级流
成员方法说明
public object readobject()把序列化到本地文件中的对象，读取到程序中来

  public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\a.txt"));
        //读取数据
        Student student = (Student)ois.readObject();
        //
        System.out.println(student);
        //释放资源
        ois.close();
    }

打印流

打印流（PrintStream和PrintWriter）是Java中用于输出文本信息的流。它们可以将文本信息输出到控制台、文件、网络等地方。

PrintStream是OutputStream的子类，可以将文本信息输出到字节流中，它提供了多种打印方法，如print、println、printf等，可以输出不同类型的数据。PrintStream还提供了自动刷新缓冲区的功能，可以在每次输出后自动刷新缓冲区。

PrintWriter是Writer的子类，可以将文本信息输出到字符流中，它也提供了多种打印方法，如print、println、printf等，可以输出不同类型的数据。PrintWriter还提供了自动刷新缓冲区的功能，可以在每次输出后自动刷新缓冲区。

使用打印流的好处是可以方便地输出各种类型的数据，并且可以自动刷新缓冲区，避免输出数据不完整的问题。同时，打印流还提供了格式化输出的功能，可以根据需要进行格式化输出。

在使用打印流时，需要注意及时关闭流，避免资源泄露和数据丢失。另外，需要注意打印流的输出位置和目标，避免输出到错误的位置和目标。

字节打印流

构造方法说明
public Printstream(outputstream/File/string)关联字节输出流/文件/文件路径
public Printstream(string fileName,charset charset)指定字符编码
public Printstream(outputstream out， boolean autoFlush)自动刷新
public Printstream(outputstream out，boolean autoFlush，string encoding)指定字符编码且自动刷新
成员方法说明
public void write(int b)常规方法:规则跟之前一样，将指定的字节写出
public void println( Xxx Xx)特有方法:打印任意数据，自动刷新，自动换行
public void print(Xxx xx)特有方法:打印任意数据，不换行
public void printf(String format，0Object. .. args)特有方法:带有占位符的打印语句，不换行
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        //创建字节打印流对象
        PrintStream ps = new PrintStream(new FileOutputStream("D:\\a.txt"),true,"UTF-8");
        //写成数据
        ps.println(97);
        ps.print(true);
        ps.printf("%s爱上了%s","阿珍","阿强");

        //释放资源
        ps.close();
    }

字符打印流

构造方法说明
public Printwriter(write/File/string)关联字节输出流/文件/文件路径
public Printwriter( String fileName，Charset charset)指定字符编码
public Printwriter(write w, boolean autoFlush)自动刷新
public PrintWriter(outputStream out，boolean autoFlush，Charset charset)指定字符编码且自动刷新
成员方法说明
public void write(....)常规方法:规则跟之前一样，写出字节或字符串
public void println( Xxx Xx)特有方法:打印任意数据类型且换行
public void print(Xxx xx)特有方法:打印任意数据，不换行
public void printf(String format，Object. .. args)特有方法:带有占位符的打印语句
 public static void main(String[] args) throws IOException {
        //创建字符打印流的对象
        PrintWriter pw = new PrintWriter(new FileWriter("D:\\a.txt"),true);
        //写数据
        pw.println("张三");
        //释放资源
        pw.close();
    }

解压缩流

解压流

解压本质:把每一个ZipEntry按照层级拷贝到本地另一个文件夹中

 public static void main(String[] args) throws IOException {
        //创建一个file表示要解压的压缩包
        File src = new File("D:\\aaa.zip");
        //创建一个File表示解压的目的地
        File dest = new File("D:\\");
        //掉方法
        unzip(src,dest);
    }
    //定义一个解压方法
    private static void unzip(File src, File dest) throws IOException {
        //解压的本质:把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中
        //创建一个解压缩流用来读取压缩包中的数据
        ZipInputStream zip = new ZipInputStream(new FileInputStream(src));
        //要先获取到压缩包里面的每一个zipentry对象
        // 表示当前在压缩包中获取到的文件或者文件夹
        ZipEntry entry;
        while ((entry = zip.getNextEntry()) != null){
            System.out.println(entry);
            if (entry.isDirectory()){
                //文件夹:需要在目的地dest处创建一个同样的文件夹
                File file = new File(dest,entry.toString());
                file.mkdirs();
            }else {
                //文件:需要读取到压缩包I的文件，并把他存放到目的地dest文件夹中（按照层级目录进行存放)
                FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));
                int b;
                while ((b = zip.read()) != -1){
                    //写到目的地
                    fos.write(b);
                }
                //表示在压缩包中的一个文件处理完毕了。
                fos.close();
                zip.closeEntry();
            }
        }
        
        zip.close();
    }

压缩流

压缩本质:把每一个(文件/文件夹）看成ZipEntry对象放到压缩包中
压缩单个文件

public static void main(String[] args) throws IOException {
        //创建一个file表示要解压的压缩包
        File src = new File("D:\\a.txt");
        //创建一个File表示解压的目的地
        File dest = new File("D:\\");
        //掉方法
        tozip(src,dest);
    }

    /**
     * 压缩
     * @param src 要压缩的文件
     * @param dest 压缩包的位置
     * @throws IOException
     */
    private static void tozip(File src, File dest) throws IOException {
        //创建压缩流关联对象
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest,"a.zip")));
        //2.创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹
        ZipEntry entry = new ZipEntry("a.txt");
        //.把ZipEntry对象放到压缩包当中
        zos.putNextEntry(entry);
        //把src文件中的数据写到压缩包当中
        FileInputStream fis = new FileInputStream(src);

        int b;
        while ((b = fis.read()) != -1){
            zos.write(b);
        }
        zos.closeEntry();
        zos.close();

    }

 压缩文件夹

public static void main(String[] args) throws IOException {
        //创建File对象表示要压缩的文件夹
        File src = new File("D:\\aaa");
        //创建File对象表示压缩包放在哪里（压缩包的父级路径)
        File destParent = src.getParentFile();
        //创建File对象表示压缩包的路径
        File dest = new File(destParent,src.getName() + ".zip");
        //创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));
        //获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
        tozip(src,zos,src.getName());

        zos.close();
    }

    /**
     * 获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
     * @param src 数据源
     * @param zos 压缩流
     * @param name 压缩包内部的路径
     */
    private static void tozip(File src, ZipOutputStream zos, String name) throws IOException {

        //
        File[] files = src.listFiles();

        for (File file : files) {
            if (file.isFile()){
                //
                ZipEntry entry = new ZipEntry(name + "\\" + file.getName());
                zos.putNextEntry(entry);
                //
                FileInputStream fis = new FileInputStream(file);
                int b;
                while ((b = fis.read()) != -1){
                    zos.write(b);
                }
                fis.close();
                zos.closeEntry();
            }else {
                tozip(file,zos,name + "\\" + file.getName());
            }
        }
    }

IO流工具

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

常见方法：

FileUtils类(文件/文件夹相关)说明
static void copyFile(File srcFile，File destFile)复制文件
static void copyDirectory(File srcDir，File destDir)复制文件夹
static void copyDirectoryToDirectory(File srcDir， File destDir)复制文件夹
static void deleteDirectory(File directory)删除文件夹
static void cleanDirectory(File directory)清空文件夹
static string readFileToString(File file，Charset encoding)读取文件中的数据变成成字符串
static void write(File file，CharSequence data，string encoding)写出数据
IOUtils类（流相关相关)说明
public static int copy(InputStream input，outputStream output)复制文件
public static int copyLarge(Reader input，writer output)复制大文件
public static string readLines(Reader input)读取数据
public static void write(String data，outputstream output)写出数据

Poetry-Distance
关注
专栏目录
java IO流学习笔记
12-12
java IO流学习笔记
java IO流 教程宝典
05-24
Java IO流教程宝典 Java中的IO流是用于在程序与外部资源（如磁盘、网络、内存等）之间传输数据的重要工具。流的概念源于计算机科学中的数据流思想，它代表了数据的有序传输。在Java中，IO流提供了一种标准化的方式...
Java IO教程
weixin_33816946的博客
03-26 138
原文链接作者：Jakob Jenkov译者：Connor (cronnorc@gmail.com) ，李璟 校对：方腾飞 Java IO 是一套Java用来读写数据（输入和输出）的API。大部分程序都要处理一些输入，并由输入产生一些输出。Java为此提供了java.io包。 如果你浏览下java.io包，会对其中各样的类选择感到迷惑。这些类的作用都是什么？对于某个任务该选择哪个类？怎样...
JavaIO
最新发布
weixin_73778697的博客
08-23 483
这个小项目演示了如何使用Java进行基本的文件操作、对象序列化、以及简单的用户交互。你可以根据需要扩展这个项目，比如添加图书删除功能、图书搜索功能、或者提供更复杂的用户界面。
JavaIO流
Switch的博客
11-09 1万+
IO流 文件--基本概念 文件是数据源(保存数据的地方)的一种，比如大word文档、jpg文件、MP4文件...都是文件。文件最主要的作用就是保存数据，它既可以保存一张图片，也可以保存视频、声音...等   文件流--基本概念 文件在程序中是以流的形式来操作的。 流：数据在数据源(文件)和程序(内存)之间经历的路径 输入流：数据从数据源(文件)到程序(内存)的路径 输出
Java IO _字节流与字符流
韩世雷 程序员专栏
08-23 1352
1.掌握流的概念 2.掌握字节流与字符流的作用 3.掌握文件的标准操作步骤 4.掌握字节与字符操作的区别 1、流的概念 程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。 2、字节流与字符流 内容操作就四个类：OutputStream、InputStream、writer、Rader 使用 File 类操作的时候一定要有路
Java IO流详解
weixin_34034670的博客
04-15 154
参考转载地址：https://blog.csdn.net/zhangliangzi/article/details/51226652 　　　　　　　http://www.cnblogs.com/ysocean/p/6870069.html 　　　　　　　https://www.cnblogs.com/jmsjh/p/7761272.html 　　　　　　　http://blog.csdn.n...
完整版 Java基础入门教程 Java程序语言设计 04 IO流 输入输出流（共31页）.ppt
12-25
完整版 Java基础入门教程 Java程序语言设计 04 IO流 输入输出流（共31页）.ppt 完整版 Java基础入门教程 Java程序语言设计 05 GUI AWT 事件模型（共27页）.ppt 完整版 Java基础入门教程 Java程序语言设计 05 GUI GUI...
java-IO流学习使用教程
06-14
Java IO流是Java平台中处理输入输出操作的重要组成部分，它允许程序与外部设备（如硬盘、网络、内存等）进行数据传输。Java IO流分为两大类：字节流（Byte Stream）和字符流（Character Stream）。本文将详细介绍...
Java-Java IO编程教程
11-13
本视频教程将详细讲解Java IO的各种概念、类库和使用方法，通过实例演示如何进行文件操作、网络通信以及高级IO技术，如对象序列化和NIO。通过学习，你将能够灵活运用Java IO解决实际问题，提升自己的编程技能。记得...
586.584.JAVA基础教程_IO流-IO流的体系结构(586).rar
11-09
Java中的IO流是进行输入/输出操作的核心机制，它允许程序与各种数据源（如文件、网络连接、内存缓冲区等）进行数据交换。在Java中，IO流被设计为一个层次化的体系结构，便于理解和使用。这个体系结构是根据流的方向...
Java-IO流学习
akxnxbshai的博客
11-16 468
java-IO学习
Java io流学习
热门推荐
hua226的博客
04-12 2万+
Java io 一、File 1.1 File类概述和构造方法 概述： 它是文件和目录路径名的抽象表示 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。 将来是要通过具体的操作把这个路径的内容转换为具体存在的。 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 File(String parent,String child) 从父路径名字符串
JAVA IO流详解
u012815721的专栏
05-08 4566
一、流的概念和作用。 流是一种有顺序的，有起点和终点的字节集合，是对数据传输的总成或抽象。即数据在两设备之间的传输称之为流，流的本质是数据传输，根据数据传输的特性讲流抽象为各种类，方便更直观的进行数据操作。 二、IO流的分类。 根据数据处理类的不同分为：字符流和字节流。 根据数据流向不同分为：输入流和输出流。 三、字符流和字节流。 字符流的由来：因为数据编码的不同，而有了对字符进行高效
Java IO最详解，欢迎提出意见
DavidIsOK
08-20 5586
Java IO 详解 初学java，一直搞不懂java里面的io关系，在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术，所以自己来整理一下，有错的话请指正，也希望大家提出宝贵意见。 首先看个图：（如果你也是初学者，我相信你看了真个人都不好了，想想java设计者真是煞费苦心啊！）   这是java io 比较基本的一些处理流，除此之外我们还会...
Java IO流
weixin_30576827的博客
04-02 101
IO流：概述、字符流、缓冲区 一、IO流概述 概述： IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，java对于数据的操作都是通过流实现，而java用于操作流的对象都在IO包中。 分类： 按操作数据分为：字节流和字符流。 如：Reader和InpurStream 按流向分：输入流和输出流。如：InputSt...
java学习：IO流
刘松松的博客
10-13 176
1、File的使用 java.io.file类：表示文本或文件夹(目录路径)，与平台无关的一种抽象表示方式。 可以进行新建、删除、重命名等操作，但是不能操作文件内容本身，如果需要访问文件内容则使用输入输出流。 构造器：File(String pathname) @Test public void test() {//创建File对象 --- 可以表示一个不存在的路径或文件 File file = ...
Java IO
weixin_34124939的博客
09-10 997
一、java io 概述 1.1 相关概念 Java IO Java IO即Java 输入输出系统。不管我们编写何种应用，都难免和各种输入输出相关的媒介打交道，其实和媒介进行IO的过程是十分复杂的，这要考虑的因素特别多，比如我们要考虑和哪种媒介进行IO（文件、控制台、网络），我们还要考虑具体和它们的通信方式（顺序、随机、二...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值