java中io流的总结和使用

4种基本流

基本流	作用
FileOutputStream(字节输出流)	可以写文件
FileInputStream（字节输入流）	可以读取文件（但是读取文本文件会存在中文乱码的问题，可以使用FileReader读取文本文件，不会出现乱码。但是图片的读取，视频读取不存在中文乱码的问题，FileInputStream可以读取它们）
FileReader（字符输入流）	只能用来读取文本文件（可以解决乱码的问题）
FileWriter（字符输出流）	只能写入文本文件

1.FileOutputStream

构造方法：

• public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。

• public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

写入数据的方法：

写出字节数组：write(int b) 方法，每次可以写出一个字节数据

写出字节数组：write(byte[] b)，每次可以写出数组中的数据

写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节

相关用法：

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。

• public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。

• public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

• public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

• public abstract void write(int b) ：将指定的字节输出流。

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
         * 字节输出流FileOutputStream
         * 写出一段文字到本地文件中。（暂时不写中文）
         * 实现步骤：
         *       创建对象
         *       写出数据
         *       释放资源
         * */

        //相对路径，相对于当前项目而言
        FileOutputStream fos=new FileOutputStream("a.txt");
        //写出一个数据到文件中
        fos.write(97);
        fos.close();

    }
}

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo04 {
    public static void main(String[] args) throws IOException {
        //以追加的方式将数据输出到文件中
        FileOutputStream fos=new FileOutputStream("a.txt",true);

        String str="cbhjcbhdcbhjdxdbnwjkdx";
        //将字符串转化成字节数组  String中有很多类型转化方法，可以了解一下
        byte[] b=str.getBytes();
        //再将字节数组中的数据写入文件中  暂时不要用中文，否则会出现乱码问题
        //乱码问题我们后面再解决
        fos.write(b);

        //将换行符写入到文件中去
        byte[] a="\r\n".getBytes();
        fos.write(a);

        byte[] c="666".getBytes();
        fos.write(c);
        fos.close();
        /*
        result:

    cbhjcbhdcbhjdxdbnwjkdx
    666

         */

    }

2.FileInputStream

构造方法：

• FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

• FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1；

 使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1  ；

相关用法：

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

• public abstract int read()： 从输入流读取数据的下一个字节。

• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
        先暂时不考虑中文

        public int read();
        1.一次只能读取一个字节，并将字节的ASCII值返回
        2.读完一个字节后指针就会自动指向它后面的一个字节  实现了指针的移动
         */
        //文件的读取操作
        FileInputStream fos=new FileInputStream("a.txt");

        /*a.txt文件的内容是：
        cdecbhjcbhdcbhjdxdbnwjkdx
        666
         */

        //读取一个字节数据
        int b = fos.read();
        System.out.print((char) b);

        b=fos.read();
        System.out.print((char)b);

        b=fos.read();
        System.out.print((char)b);

        b=fos.read();
        System.out.print((char)b);

        b=fos.read();
        System.out.print((char)b);

        fos.close();
        /*输出的结果是：
        cdecb
         */
    }
}

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //循环读取文件中的所有内容
        //如果读到文件的末尾，就会返回-1
        FileInputStream fos=new FileInputStream("a.txt");
        StringBuilder sb=new StringBuilder();
        int b=0;
        while((b=fos.read())!=-1){
            sb.append((char)b);
        }
        fos.close();
        System.out.println(sb.toString());
        //打印的结果：
        //cdecbhjcbhdcbhjdxdbnwjkdx
        //666
    }
}

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamDemo03 {
    public static void main(String[] args) throws IOException {
        /*文件的内容是：
        cdecbhjcbhdcbhjdxdbnwjkdx
        666
         */


        //一个字节一个字节地读取效率太低了，现在要使用字节数组来获取文件的内容
        FileInputStream fos=new FileInputStream("a.txt");
        //创建大小为5的字节数组，五个字节一读取
        byte[] b=new byte[5];
        //获取一次读取的长度len
        int len=0;
        while((len=fos.read(b))!=-1){
            //截取字节数组中的有效长度
            //如果截取到最后的话，只读取了三个字节数据，只有这三个数据是有效的，所以只截取三个字节数据
            //因为后面两个数据没有被最新字节数据覆盖，结果会造成错误
            String str=new String(b,0,len);
            System.out.print(str);
        }
        fos.close();
        
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo04 {
    public static void main(String[] args) throws IOException {
        /*
        复制图片
        pic\pandas.jpg
        复制到
        pic\pandascopy.jpg中
         */

        FileInputStream fos=new FileInputStream("pic\\panda.jpg");
        FileOutputStream fos1=new FileOutputStream("pic\\pandascopy.jpg");
        byte[] b=new byte[1024];
        int len=0;
        while((len=fos.read(b))!=-1){
            fos1.write(b,0,len);
        }
        fos1.close();
        fos.close();

    }
}

3.FileReader

构造方法：

• FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。

• FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取；

使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ； 

相关用法：

• ublic void close() ：关闭此流并释放与此流相关联的任何系统资源。

• public int read()： 从输入流读取一个字符。

• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

 

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class CharStream01 {
    public static void main(String[] args) throws IOException {
        /*
        FileReader中的read()方法：一次读取一个字节，但是遇到中文一次会读取一个中文
        //2.读取数据 read()
        //字符流的底层也是字节流，默认也是一个字节一个字节的读取的。
        //如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节

        //read（）细节：
        //1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
        //2.在读取之后，方法的底层还会进行解码并转成十进制。
        //  最终把这个十进制作为返回值
        //  这个十进制的数据也表示在字符集上的数字
        //  英文：文件里面二进制数据 01100001
        //          read方法进行读取，解码并转成十进制97
        //  中文：文件里面的二进制数据 11100110 10110001 10001001
        //          read方法进行读取，解码并转成十进制27721

        // 我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了
         */
        FileReader fr=new FileReader("a.txt");
        int ch;
        while((ch=fr.read())!=-1){
            System.out.print((char)ch);
        }
        fr.close();
        /*
        输出结果：
        今天天气很好
        我想出去走走
         */
    }
}

import java.io.FileReader;
import java.io.IOException;

public class CharStream02 {
    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("a.txt");
        char[] ch=new char[2];
        int len=0;
        while((len=fr.read(ch))!=-1){
            System.out.print(new String(ch,0,len));
        }
        fr.close();
        /*
        结果是：
        今天天气很好
        我想出去走走
         */


    }
}

4.FileWriter

构造方法：

• FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。

• FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

 相关用法：

• void write(int c) 写入单个字符。

• void write(char[] cbuf)写入字符数组。

• abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。

• void write(String str)写入字符串。

• void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

• void flush()刷新该流的缓冲。

• void close() 关闭此流，但要先刷新它。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharStream03 {
    public static void main(String[] args) throws IOException {

        /*
            第一步：创建对象
                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)   写出字符数组的一部分

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


                '我'    25105
        */

        //追加模式
        FileWriter fw=new FileWriter("a.txt",true);
        //字符数组
        char[] ch="\r\n欣赏自然风景，感受人文情怀！".toCharArray();
        //字符串
        fw.write("\r\n我想去西湖！");
        fw.write(ch);
        fw.close();
        /*
        运行后，a.txt的内容：

        今天天气很好
        我想出去走走
        我想去西湖！
        欣赏自然风景，感受人文情怀！
         */



    }
}

转换流

1. 字符编码和字符集

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)--字节(看不懂的)

解码:字节(看不懂的)-->字符(能看懂的)

• 字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

  编码表:生活中文字和计算机中二进制的对应规则

字符集

• 字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

• ASCII字符集 ：

  • ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。

  • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。

• ISO-8859-1字符集：

  • 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。

  • ISO-8859-1使用单字节编码，兼容ASCII编码。

• GBxxx字符集：

  • GB就是国标的意思，是为了显示中文而设计的一套字符集。

  • GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。

  • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。

  • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。

• Unicode字符集 ：

  • Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。

  • 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。

  • UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：

    1. 128个US-ASCII字符，只需一个字节编码。

    2. 拉丁文等字符，需要二个字节编码。

    3. 大部分常用字（含中文），使用三个字节编码。

    4. 其他极少使用的Unicode辅助字符，使用四字节编码。

2 编码引出的问题

在IDEA中，使用FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的UTF-8编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。那么如何读取GBK编码的文件呢？

public class ReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
        int read;
        while ((read = fileReader.read()) != -1) {
            System.out.print((char)read);
        }
        fileReader.close();
    }
}
输出结果：
���

3.InputStreamReader（输入转换流）

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法：

• InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。

• InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

以指定的解码格式读取文件

import java.io.*;
import java.nio.charset.Charset;

public class ConvertStream01 {
    public static void main(String[] args) throws IOException {
        //转换流，专门用来解决编码和解码形式不统一
        //将硬盘上的数据调用到内存中来
        //c.txt文件使用GBK进行编码
        //c.txt文件的内容是：今天天气很好！
        //1.默认用utf-8进行解码
//        InputStreamReader is=new InputStreamReader(new FileInputStream("c.txt"));
//        int b=0;
//        while((b=is.read())!=-1){
//            System.out.print((char)b);
//            //���������ܺã�  出现了错误，因为c.txt文件使用GBK进行编码，我们用的是utf-8进行解码
//        }
//        is.close();


        //2.定义用GBK进行解码文件内容，解码和编码的形式一致
//        InputStreamReader is=new InputStreamReader(new FileInputStream("c.txt"),"GBK");
//        int b=0;
//        while((b=is.read())!=-1){
//            System.out.print((char)b);
今天天气很好！        解码成功
//        }
//        is.close();


        //3.另一种方式来获取指定编码的文件内
        FileReader rf=new FileReader("c.txt", Charset.forName("GBK"));
        int b;
        while((b=rf.read())!=-1){
            //今天天气很好！
            System.out.print((char)b);

        }
        rf.close();

    }
}

4.OutputStreamWriter（输出转换流）

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法：

• OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。

• OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

• 以指定的编码格式写入文件

import java.io.*;
import java.nio.charset.Charset;

public class ConvertStream02 {
    public static void main(String[] args) throws IOException {
        /*
        OutputStreamWriter
        以指定的编码格式编写文件内容，默认是utf-8
         */
        //1.方式一
//        OutputStreamWriter os=new OutputStreamWriter(new FileOutputStream("e.txt"),"GBK");
//        os.write("你好你好！");
//        os.close();

        //方式2
        FileWriter fw=new FileWriter("e.txt",Charset.forName("GBK"),true);
        fw.write("\r\n好久不见！");
        fw.close();
    }
}

import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

public class ConvertStream03 {
    public static void main(String[] args) throws IOException {
        //将e.txt文件中格式转化为utf-8并保存到另一个文件中去f.txt
        //在读取的时候，先将文件内容以GBK的形式解码，再将解码后的数据地读入到内存中去
        InputStreamReader is=new InputStreamReader(new FileInputStream("e.txt"),"GBK");
        //将内存中数据再以编码为utf-8的形式写入到硬盘中（f.txt文件）
        OutputStreamWriter os=new OutputStreamWriter(new FileOutputStream("f.txt"), "UTF-8");
        char[] b=new char[1024];
        int len;
        while((len=is.read(b))!=-1){
            os.write(new String(b,0,len));
        }
        os.close();
        is.close();
        //此时打开文件f.txt，文件的内容就不会像e.txt一样出现乱码的现象

    }
}

缓冲流

缓冲流
字节缓冲流	BufferedInputStream
	BufferedOutputStream
字符缓冲流	BufferedReader
	BufferedWriter

缓冲流可以加快文件的读取和写入速度，缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

1.BufferedInputStream(缓冲输入字节流)  BufferedOutputStream（缓冲输出字节流）

构造方法：

• public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。

• public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。

这两个字节缓冲流的用法与FileInputStream,FileOutputStream相同

import java.io.*;

public class BufferedStream01 {
    public static void main(String[] args) throws IOException {
        /*原来文件中的内容：
        今天天气很好
        我想出去走走
        我想去西湖！
        欣赏自然风景，感受人文情怀！
     */
        //将a.txt文件中的数据加载到缓冲区中
        BufferedInputStream bi=new BufferedInputStream(new FileInputStream("a.txt"));
        //再将缓冲区中的数据追加到源文件中
        BufferedOutputStream bo= new BufferedOutputStream(new FileOutputStream("a.txt",true));
        int b;
        while((b=bi.read())!=-1){
            bo.write((char)b);
        }
        bo.close();
        bi.close();
        /*
        程序运行完后的内容：
        今天天气很好
        我想出去走走
        我想去西湖！
        欣赏自然风景，感受人文情怀！今天天气很好
        我想出去走走
        我想去西湖！
        欣赏自然风景，感受人文情怀！
         */

    }
}

import java.io.*;

public class BufferedStream02 {
    public static void main(String[] args) throws IOException {
        /*原来文件中的内容：
        今天天气很好
        我想出去走走
        我想去西湖！
        欣赏自然风景，感受人文情怀！
     */
        BufferedInputStream bi=new BufferedInputStream(new FileInputStream("a.txt"));
        BufferedOutputStream bo=new BufferedOutputStream(new FileOutputStream("a.txt",true));
        byte[] b=new byte[1024];
        int len;
        while((len=bi.read(b))!=-1){
            System.out.println(new String(b,0,len));
            bo.write(b,0,len);
        }
        bo.close();
        bi.close();

        /*
        程序运行完后的内容：
        今天天气很好
        我想出去走走
        我想去西湖！
        欣赏自然风景，感受人文情怀！今天天气很好
        我想出去走走
        我想去西湖！
        欣赏自然风景，感受人文情怀！
         */

    }

}

2.BufferedReader（缓冲输入字符流）BufferedWriter（缓冲输出字符流）

构造方法：

• public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。

• public BufferedWriter(Writer out)： 创建一个新的缓冲输出流。

字符缓冲流的基本方法与普通字符流调用方式一致。

特有方法：

• BufferedReader：public String readLine(): 读一行文字。

• BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

import java.io.*;
import java.nio.charset.Charset;

public class BufferedStream03 {
    public static void main(String[] args) throws IOException {

        BufferedReader br=new BufferedReader(new FileReader("e.txt", Charset.forName("GBK")));
        BufferedWriter bw=new BufferedWriter(new FileWriter("h.txt",Charset.forName("GBK")));

        int b;
        while((b=br.read())!=-1){
            bw.write(b);
        }
        bw.close();
        br.close();

    }
}

import java.io.*;
import java.nio.charset.Charset;

public class BufferedStream04 {
    public static void main(String[] args) throws IOException {

        BufferedReader br=new BufferedReader(new FileReader("e.txt", Charset.forName("GBK")));
        BufferedWriter bw=new BufferedWriter(new FileWriter("h.txt",Charset.forName("UTF-8")));

//
        String s=new String();
        while ((s=br.readLine())!=null) {
            bw.write(s);
            //换行操作
            bw.newLine();
        }

        bw.close();
        br.close();


    }

}

解压缩流

压缩流：

负责压缩文件或者文件夹

解压缩流：

负责把压缩包中的文件和文件夹解压出来

这个过程要自己好好体会总结

11.ZipOutputStream(压缩流)

实质就是将文件夹中的每一个文件和文件夹压缩

这个代码是压缩一个文件（不是文件夹）

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipDemo01 {
    public static void main(String[] args) throws IOException {

        //读取要压缩的文件输入流
        File file = new File("D:\\zlibrary网址.txt");
        FileInputStream fi=new FileInputStream(file);
        //创建压缩文件的输出流
        ZipOutputStream zos=new ZipOutputStream(new FileOutputStream("D:\\zlibrary网址.zip"));
        //记住，在压缩时要注意添加文件的后缀名（文件类型）
        ZipEntry entry = new ZipEntry(file.getName());
        zos.putNextEntry(entry);
        byte[] b=new byte[1024];
        int len;
        while((len=fi.read(b))!=-1){
            zos.write(b,0,len);
        }
        zos.closeEntry();
        fi.close();
        zos.close();
//成功了


    }
}

这是压缩一个文件，如果是文件，就压缩，不是文件就继续递归

String name 代表压缩文件夹的内部路径 

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class zipDemo02 {
    public static void main(String[] args) throws IOException {
        //压缩一个文件夹
        /*
        原理是将源文件夹中的每一条路径上的文件进行压缩，要保证路径还原
         */
        File src=new File("D:\\panda_c");
        File des=new File(src+".zip");

        //des不存在就会自动创建
        ZipOutputStream zos=new ZipOutputStream(new FileOutputStream(des));
        zip(src,zos,src.getName());
        zos.close();

//        System.out.println(src);
//        System.out.println(des);
    }
    //压缩文件夹成功了
    public static void zip(File src,ZipOutputStream zos,String name) throws IOException {
        File[] files = src.listFiles();
        if(files==null){
            return;
        }

        for(File f:files){
            if(f.isFile()){
                //读取要压缩的文件的内容
                FileInputStream fi=new FileInputStream(f);
                ZipEntry entry = new ZipEntry(name+"\\"+f.getName());
                zos.putNextEntry(entry);
                byte[] b=new byte[1024];
                int len;
                while((len=fi.read(b))!=-1){
                    zos.write(b,0,len);
                }
                fi.close();
                zos.closeEntry();
            }else{
                zip(f,zos,name+"\\"+f.getName());
            }
        }
    }
}
/*
1.创建文件夹对象        File src=new File("D:\\aaa")
2.创建文件夹压缩后的文件对象     File des=new File("D:\\aaa.zip")
3.将压缩后的文件对象des传入ZipOutputStream压缩流对象中进行压缩操作  zip=new ZipOutputStream(des)
4，创建ZipEntry(压缩文件夹内部存储的文件路径)对象  entry=new ZipEntry("aaa\\bbb\\a.txt")
例如：
   如果D:\aaa.zip中只有一个bbb文件夹，则bbb文件夹在压缩文件内部的存储路径就是是“bbb”
   如果D:\aaa.zip中只有一个bbb文件夹，文件夹bbb的下面有一个a.txt,则a.txt文件在压缩文件内部的存储路径就是是“bbb\\a.txt”
   自己领悟吧！
5.将创建的ZipEntry对象传入到zos.putNextEntry(entry)，开始操作aaa\\bbb\\a.txt对象
6.将src中的“D:\\aaa\\bbb\\a.txt”文件中的内容写入到zos中
                FileInputStream fi=new FileInputStream(“D:\\aaa\\bbb\\a.txt”);
                ZipEntry entry = new ZipEntry(“aaa\\bbb\\a.txt”);
                zos.putNextEntry(entry);
                byte[] b=new byte[1024];
                int len;
                while((len=fi.read(b))!=-1){
                    zos.write(b,0,len);
                }
                zos.closeEntry()//要将这个创建出来entry对象关闭
                fi.close();


自己慢慢领悟吧，好好总结一下
 */

 

12.ZipInputStream（解压缩流）

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

public class zipDemo03 {
    public static void main(String[] args) throws IOException {
        //解压文件
        File file=new File("D:\\zlibrary网址.zip");
        File des=new File("E:\\");


        ZipInputStream zis=new ZipInputStream(new FileInputStream(file));
        ZipEntry entry = zis.getNextEntry();
        System.out.println(entry);//压缩包内部的路径：zlibrary网址
        File f=new File(des,entry.toString());
        FileOutputStream fos=new FileOutputStream(f);
        byte[] b=new byte[1024];
        int len;
        while((len=zis.read(b))!=-1){
            fos.write(b,0,len);
        }
        fos.close();
        zis.closeEntry();
        zis.close();


    }


}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class zipDemo04 {
    public static void main(String[] args) throws IOException {
        //解压文件夹
        File src=new File("D:\\panda_c.zip");
        File des=new File("E:\\");

        ZipInputStream zis=new ZipInputStream(new FileInputStream(src));

        unzip(des,zis);
        zis.close();


    }
    public static void unzip(File des,ZipInputStream zis) throws IOException {
        ZipEntry entry;
        while ((entry = zis.getNextEntry())!=null) {
            File file=new File(des,entry.toString());
            //给父级目录创建文件，如果父级目录存在，就不会再创建
            new File(file.getParent()).mkdirs();
            byte[] b=new byte[1024];
            int len;
            FileOutputStream fos=new FileOutputStream(file);
            //将压缩文件的内容写入到新的文件中
            while((len=zis.read(b))!=-1){
                fos.write(b,0,len);
            }
            zis.closeEntry();
            fos.close();
        }
    }


}
/*
将压缩文件对象中的每个ZipEntry对象取出来，解压到目标文件中
如果是层级目录下的文件，就要先创建出层级目录文件夹，再创建文件，并将文件的内容一起写出去
好好体会吧
*/