java的io

字节输出流（FileOutputStream）#

• 步骤：

  1. 创建对象（FileOutputStream fos=new FileOutputStream(“test.txt”);）
  2. 写出数据（.write()）

  这write方法有三个重载版本

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

  3. 释放（.close()）

• 小细节：

  • 一，创建对象：
    1. 参数可以是字符串或者file对象
    2. 如果文件地址不存在，会新建这个文件，但是要保证父地址是完整的
    3. 如果文件本身有内容，会被覆盖
  • 二，写出数据：
    1. write方法虽然传入的是整数，但实际上是整数在ASCII上对应的字符
    2. 在文件里换行：使用“\r\n”。
    3. 续写：在创建对象的时候，参数多加一个true，表示续写开关，默认是false

字节输入流（FileInputStream）#

• 步骤：

  1. 创建对象
  2. 读取数据（.read）

  有两个重载

  方法名称	说明
  int read()	一次读一个字节数据
  public int read(byte[] buffer)	一次读一个字节数组数据（用于大文件的读取）

  3. 释放（.close()）

• 小细节：

  • 一，创建对象：
    1. 文件地址不存在会直接保存
  • 二，读取数据
    1. 一次读取一个字节，读出来返回的是数据的ASCII对应数字
    2. 读到文件末尾以后会返回-1

应用示例#

那么循环读取就可以这么写

1
    FileInputStream fis=new FileInputStream("test.txt");
2
    FileOutputStream fos=new FileOutputStream("test2.txt");
3
    int i=0;
4
    while((i=fis.read())!=-1){
5
        fos.write(i);
6
    }
7
    fos.close();
8
    fis.close();

结合使用read的重载，read(byte[] buffer)，可以一次性读多个数据，提高效率

它的运行方式是，每次把读到的数据放在传入的数组里，直到数组填满，同时会返回本次读取的长度int length 例如下例，把test1的数据复制到test2

1
public static void main(String[] args) throws IOException {
2
        FileOutputStream fos=new FileOutputStream("test1.txt");
3
        FileInputStream fis=new FileInputStream("test2.txt");
4
        byte[] b=new byte[1024];
5
        int len;
6
        while((len=fis.read(b))!=-1){
7
            fos.write(b,0,len);
8
        }
9
        fos.close();
10
        fis.close();

字符输入流（FileReader）#

• 步骤：

1. 创建字符输入流对象

   方法名称	说明
   public FileReader(File file)	创建字符输入流关联本地文件
   public FileReader(String pathname)	创建字符输入流关联本地文件

   • 细节：
     • 文件地址不存在会报错

2. 读取数据（read）

   方法名称	说明
   public int read()	读取数据，读到末尾返回 - 1
   public int read(char[] buffer)	读取多个数据，读到末尾返回 - 1

   • 细节：
     • 1：按字节进行读取，遇到中文，一次读多个字节，读取后解码成十进制，如果要以中文汉字或者英文的形式呈现，只需要做一个char类型的强转，因为char类型正好
     • 2：读到文件末尾了，read 方法返回 - 1。 示例：

   1
   File f =new File("C:\\Users\\LY\\Desktop\\files\\aaa.txt");
   2
       FileReader fr=new FileReader(f);
   3
       int i=0;
   4
       while((i=fr.read())!=-1){
   5
           System.out.print((char) i);
   6
       }

   • 对于有参read（char[] buffer）: 把读取，解码，强转集合起来了，并把结果放进了buffer数组中，所以我们想要结果只要遍历数组（给的数组足够大，或者文件足够小）或者把数组用string类型拼接。

3. 释放

字符输出流（FileWriter）#

步骤

1. 创建字符输出流对象

   方法名称	说明
   public FileWriter(File file)	创建字符输出流关联本地文件，默认覆盖写入
   public FileWriter(String pathname)	创建字符输出流关联本地文件，默认覆盖写入
   public FileWriter(File file, boolean append)	创建字符输出流关联本地文件，append=true 开启续写
   public FileWriter(String pathname, boolean append)	创建字符输出流关联本地文件，append=true 开启续写

   • 细节：
     • 1：参数是字符串表示的路径或者 File 对象都是可以的
     • 2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的
     • 3：如果文件已经存在，则会清空文件，如果不想清空可以打开续写开关

2. 写出数据

   方法名称	说明
   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：如果write方法的参数是整数，但是实际上写到本地文件中的是整数在字符集上对应的字符。

3. 释放

缓冲流介绍#

它在原来基础的字节流或者字符流的基础上，加了一个缓冲区，缓冲区的大小是8192字节。

下面是他的体系图

字节缓冲流#

构造方法

字符缓冲流#

由于字符流本就自带缓冲区，所以在这里的效率提升不明显

针对字符流输入输出的两个方法

转换流介绍#

他是在字符流基础上的高级流，因此他本质是一个字符流

作用：是字符流和字节流的桥梁，能让字节流变成字符流然后使用对应方法

以下是体系图

转换流使用方式#

构造方法

另外他还有另一种构造，能够解析各种编码格式

但其实这种方式在jdk11以后已经被淘汰了，可以这样想，这个转换流对象本质也是字符流，那为啥不在字符流的构造里加一个能够设定编码格式的构造方法呢

所以我们可以使用字符流的这种构造方式，实现解析各种编码格式

序列化流介绍#

是字节流下的高级流，他的主要作用是把对象信息写进文件中，后续可以通过反序列化流获取信息

以下是体系图

序列化使用方式#

基本的构造方法

它对应的写入方法是不一样的

小细节：如果想要用序列化写入对象，那这个类一定要实现Serializable接口,否则会报NotSerializableException，这个接口是标志性接口，他没有抽象方法，仅作为一个标签表示这个类可以被序列化写入

反序列化使用方式#

基本的构造方法

对应的读取方法是不一样的

值得关注的是，他的返回值是object的，所以我们还要去强转成原来的类型

字节打印流（PrintStream）#

有四个构造方法

有四个成员方法

注：这的三个特有方法都支持原样写出，即写出97就是97，而不会按ASCII转成a

字符打印流（PrintWriter）#

多一个缓冲区

有四个构造方法

有四个成员方法

注：这的三个特有方法都支持原样写出，即写出97就是97，而不会按ASCII转成a

知识补充，我们平时用的标准输出流System.out.print就是一种特别的打印流#

介绍与前提知识补充#

这里的压缩包，是由压缩流的构造方法创建的，在这压缩流里存的就是ZipEntry的对象

所以要先了解ZipEntry的构造

ZipEntry有一个好用的方法

体系图

解压缩流：#

本质是把一个ZipEntry的对象按层级拷贝到本地的另一个文件夹中

解压缩流的构造

它有一个常用方法，来获取解压出的文件

1
    File f1=new File("C:\\Users\\LY\\Desktop\\files\\aaa.zip");
2
    ZipInputStream zis=new ZipInputStream(new FileInputStream(f1));
3
    ZipEntry ze;
4
    while((ze=zis.getNextEntry())!=null){
5
        System.out.println(ze);
6
    }

压缩流#

本质是把一个（文件/文件夹）看成ZipEntry对象放在压缩包中

• 在压缩的时候会发现，这里是先put，再去写文件内容的，这乍一看有些反直觉，但其实是小巧思。在压缩流的内部有一个特别的字段能存储put进去的zipentry对象，所以put后再去写入数据是可行的，执行完以后再用closeEntry()，就可以关闭当前的关联。这样的操作因为不用频繁的write会更快，再来就是write方法不好再加一个传入zipentry对象的构造，这会与他的工具类属性有所冲突

压缩流的构造

有常用方法

1
//先确定要被拷贝的文件流
2
        File f1=new File("C:\\Users\\LY\\Desktop\\files\\bbb.txt");//这里是要被压缩的文件
3
        //然后写进压缩流里创建流
4
        ZipOutputStream zos=new ZipOutputStream(new FileOutputStream(new File(f1.getParent()+"\\"+f1.getName().split("\\.")[0]+".zip")));//如果直接给f1，他会建一个包含f1所有层级的压缩包，所以要拼接
5
        //然后是读取要被压缩的文件地址，放进ZipEntry对象里
6
        ZipEntry ze1=new ZipEntry("bbb.txt");//在这里会完整写入层级
7
        //然后放进流里
8
        zos.putNextEntry(ze1);
9
        //要去遍历源文件，写入压缩包里的文件
10
        FileInputStream fis1=new FileInputStream(f1);
11
        int i;
12
        while((i=fis1.read())!=-1){
13
            //内部的字段会存储这个对象地址,然后执行的写入也会写进对应的地方
14
            zos.write(i);//写入原文件的数据
15
        }
16
        //使用closeEntry()可以关闭当前的文件关联，然后就可以put新的ZipEntry对象了
17
        zos.closeEntry();
18
        zos.close();

1
public class Test6 {
2
    public static void main(String[] args) throws IOException {
3
        //压缩文件夹，那就要考虑几个事
4
        //1，文件夹需要遍历，判断，那就需要递归
5
        //2，压缩包位置需要做好拼接
6

7
        //先不论别的，先创建被压缩文件流
8
        File f1=new File("C:\\Users\\LY\\Desktop\\files\\1");
9
        ZipOutputStream zop=new ZipOutputStream(new FileOutputStream(new File(f1.toString()+".zip")));
10
        try {
11
            toZip(f1,zop,f1.getName());
12
        } catch (IOException e) {
13
            throw new RuntimeException(e);
14
        }finally {
15
            zop.close();
16
        }
17

18
    }
19

20
    //需要遍历，那就要声明方法
21
    //这个方法优先实现对原文件的遍历功能
22
    //首先需要源文件的流,压缩流，压缩包内部的地址
23
    public static void toZip(File f1,ZipOutputStream zos,String name) throws IOException {
24
        File[] files=f1.listFiles();
25
        for(File file:files){
26
            if(file.isFile()){
27
                //是文件
28
                //要创建zipentry对象
29
                ZipEntry entry=new ZipEntry(name+"\\"+file.getName());
30
                //要在压缩流put
31
                zos.putNextEntry(entry);
32
                //创建字节输入流
33
                FileInputStream fis=new FileInputStream(file);
34
                int i;
35
                while((i=fis.read())!=-1){
36
                    //遍历写入
37
                    zos.write(i);
38
                }
39
                fis.close();
40
                zos.closeEntry();
41
            }else{
42
                //是文件夹
43
                ZipEntry entry=new ZipEntry(name+"\\"+file.getName()+"\\");//在文件名后面加一个\就可以表示空条目
44
                zos.putNextEntry(entry);
45
                zos.closeEntry();
46
                //递归遍历
47
                //能确定压缩流不变
48
                //拼接得要遍历得文件夹
49
                toZip(file,zos,name+"\\"+file.getName());
50
            }
51
        }
52
        //实现遍历，先判断是文件还是文件夹
53
    }
54
}