IO

一、IO分类

1.1、总的分类

1.2、按流向分类

输入流

​ 数据源到程序(InputStream、Reader读进来)

输出流

​ 程序到目的地(OutPutStream、Writer写出去)

1.3、按功能分类

节点流

​ 可以直接从数据源或目的地读写数据。

处理流

​ 不直接连接到数据源或目的地，是处理流的流。通过对其他流的处理提高程序的性能。

1.4、按处理的数据单元

字节流

按照字节读取数据(InputStream、OutputStream)

​ 字节流能够处理一切的内容，包括文本和非文本， 可能存在乱码，但是我们可以设置编码格式解决乱码。麻烦

字节流 的节点流 FileInputStream、FileOutputStream

读入(从文件中读入到内存)

int read(byte[] bs)

import java.io.*;

public class Demo003ReadStream {
    
    public static void main(String[] args) throws IOException {
    
        // 抽象文件对象
        File file = new File("a.txt");
        // 提升作用域
        InputStream is = null;

        // 中文 在 GBK 占两个字节     在utf-8占3个字节
        // 打开流
        is = new FileInputStream(file);
        byte[] bs = new byte[1024];
        int len;
        while ((len = is.read(bs)) != -1) {
    
            System.out.println(new String(bs, 0, len, "UTF-8"));
        }

        if (is != null) {
    
            is.close();
        }

    }
}
//运行结果
你我他1234

写出(从内存写出到文件中）

write(byte[] bs)

import java.io.*;

/**
 * 字节流写出文件
 * 1、文件
 * 2、流
 */
public class Demo006WriterStream {
    
    public static void main(String[] args) throws IOException {
    
        // 1、文件
        File file = new File("a.txt");
        // 2、流
        OutputStream os = new FileOutputStream(file, true);   // 第二个参数 appeend:true 可以追加，不覆盖

        byte[] bs = "ab".getBytes("utf-8");

        // 写出
        os.write(bs);
        // 刷新
        os.flush();
        os.close();
    }
}

运行结果

读入和写出 copy

int read(byte[] car)

write(byte b[], int off, int len)

package com.shsxt.io;

import java.io.*;

public class Demo009CopyStream {
    
    public static void main(String[] args) throws IOException {
    
        // 源头
        File src = new File("test.png");
        // 目的地
        File dest = new File("testcopy.png");

        InputStream is = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        byte[] car = new byte[2];
        int len ;
        while((len=is.read(car))!=-1){
    
            os.write(car,0,len);
        }
        os.flush();
        os.close();
        is.close();
    }
}

字节流 的处理流 BufferedInputStream、BufferedOutputStream

读入

​ BufferedInputStream(InputStream in) 创建一个BufferedInputStream 并保存其参数，输入流 in ，供以后使用。

​ BufferedInputStream(InputStream in, int size) 创建BufferedInputStream 具有指定缓冲区大小，并保存其参数，输入流in ，供以后使用。

int read(byte[] car)

import java.io.*;

/**
 * 处理流  需要有结点留存在
 */
public class Demo001BufferedInputStream {
    
    public static void main(String[] args) throws IOException {
    
        // 获取节点流连接到文件
        InputStream is = new FileInputStream("a.txt");
        // 处理流  套在结点流之上
        BufferedInputStream bis = new BufferedInputStream(is);

        byte[] car = new byte[1024];
        int len;
        while((len = bis.read(car))!=-1){
    
            System.out.println(new String(car,0,len,"utf-8"));
        }

        // 内部会帮我们关闭其他流
        bis.close();


    }
}

写出

write(byte b[])

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Demo003BufferedOutputStream {
    
    public static void main(String[] args) throws IOException {
    
        OutputStream os = new FileOutputStream("a.txt",true);
        BufferedOutputStream bos = new BufferedOutputStream(os);
        bos.write("核力量".getBytes());
        bos.flush();
        bos.close();
    }
}

字符流

字符流 的节点流 FileReader、FileWriter

按照字符读取数据(Reader、Writer)

​ 字符流只能处理文本，要嘛不出乱码，要嘛出乱码了解决不了

​ 处理的就是纯文本，字符流简单， 但是可能有乱码，解决不了

读入

int read()读取

import java.io.*;

/**
 * 字符流
 */
public class Demo004Reader {
    
    public static void main(String[] args) throws IOException {
    
        // 文件
        File file = new File("a.txt");
        Reader r = new FileReader(file);

            // 一个一个的字符读取，每个字符对应的ascii码
            int ch ;
        
            while((ch=r.read())!=-1){
    
                System.out.println((char)ch);
            }

            if(r!=null){
    
                    r.close();
            }

    }
}
//运行结果
你
我
他
1
2
3
4

int read(char[] c)读取

import java.io.*;
import java.util.Arrays;

public class Demo005Reader {
    
    public static void main(String[] args) throws IOException {
    
        // 文件
        File file = new File("a.txt");
        Reader r = new FileReader(file);

        
        // 接收读取到的字符个数
        int len ;
        
        char[] c = new char[3];
        while((len = r.read(c))!=-1){
    
            System.out.println(new String(c,0,len));
        }
        
        r.close();


    }
}
//运行结果
你我他
123
4

写出

write(String str)

package com.shsxt.io;

import java.io.*;

public class Demo007Writer {
    
    public static void main(String[] args) throws IOException {
    
        File file = new File("a.txt");
        Writer w = new FileWriter(file,true);

        String str = new String("xy".getBytes("utf-8"));
        w.write(str);
        w.flush();
        w.close();
    }
}

运行结果

读入和写出 copy

int read()

write(int c)

int read(byte[] car)

write(byte b[], int off, int len)

package com.shsxt.io;

import java.io.*;

/**
 * 字符流拷贝
 * 读 -> 写
 */
public class Demo008CopyChar {
    
    public static void main(String[] args) throws IOException {
    
        // 源头
        File src = new File("a.txt");
        // 目的地
        File dest = new File("acopy.txt");

        Reader r = new FileReader(src);
        Writer w = new FileWriter(dest);

        //  使用read()进行copy
//        int c ;
//        while((c=r.read())!=-1){
    
//            w.write(c);
//        }

        //使用read(char[] car)数组进行copy
        char[] car = new char[1024];
        int len ;
        // 循环读取
        while((len=r.read(car))!=-1){
    
            w.write(car,0,len);
        }

        w.flush();
        w.close();
        r.close();


    }
}

字符流 的处理流 BufferedReader、BufferedWriter

读入

​ BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。

​ BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。

String readLine()

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Demo002BufferedReader {
    
    public static void main(String[] args) throws IOException {
    
        Reader r = new FileReader("a.txt");
        BufferedReader br = new BufferedReader(r);

        String data;
        while(null!=(data=br.readLine())){
    
            System.out.println(data);
        }

        br.close();
    }
}

写出

write(byte b[])

package com.shsxt.bufferdio;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Demo003BufferedOutputStream {
    
    public static void main(String[] args) throws IOException {
    
        OutputStream os = new FileOutputStream("a.txt",true);
        BufferedOutputStream bos = new BufferedOutputStream(os);
        bos.write("核力量".getBytes());
        bos.flush();
        bos.close();
    }
}

1.5、字符流中存在 转换处理流: InputStreamReader 字节->字符

处理的都是字符（字节、字符）

字符流： 方便，可能不出乱码，但是一旦别人有乱码，你这个流就一定乱码

字节流：麻烦，但是只要你能够有机会不乱码，我都可以做到

转换流：将字节流转为字符流 处理乱码(编码集、解码集)。

import java.io.*;

/**
 * 转换流：
 * 字节流-> 字符流
 *
 * 文件 GBK
 * 程序  UTF-8
 */
public class Demo001 {
    
    public static void main(String[] args) throws IOException {
    
        // 解决乱码而且方便
        // 通过字节流读取文件内容， 由转换流内部帮我们将字节转为字符，而且我们设置了编码，这是文件的编码
        BufferedReader bufferedReader =new BufferedReader( new InputStreamReader(new FileInputStream("a.txt"),"GBK" ) );

        String str1 ;
        while((str1=bufferedReader.readLine())!=null){
    
            System.out.println(str1);
        }

        bufferedReader.close();
    }
}

1.6、数据处理流:DataInputStream DataOutputStream

必须先写，再读。读的顺序必须和写的顺序保持一致

可以处理基本类型+String，保留数据的类型。前提是读取顺序与写出顺序一致，否则读取数据不正确

写出 DataOutputStream

import java.io.*;

/**
 * 处理流  结点流
 */
public class Demo001DataOutputStream {
    
    public static void main(String[] args) throws IOException {
    
        OutputStream os = new FileOutputStream("b.txt");
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeUTF("趣味");
        dos.flush();
        dos.close();
    }
}

运行结果

读入 DataInputStream

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

public class Demo002DataInputStream {
    
    public static void main(String[] args) throws IOException {
    
        DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
        String str = dis.readUTF();
        System.out.println(str);
        dis.close();
    }
}
//运行结果
趣味

1.7、对象流

​ 以前我们学过的流都只能读写字节，字符形式的数据，而java中非常重要并且常见的对象类型的数据，如果想要存储到文件中应该怎么操作呢？这个时候就使用到了对象流。

序列化：是一个用于将对象状态转换为字节流的过程，可以将其保存到磁盘文件中或通过网络发送到任何其他程序

反序列化：从字节流创建对象的相反的过程称为 反序列化

ObjectOutputStream（序列化）

package com.shsxt.dataStream;

import java.io.Serializable;

public class Person implements Serializable {
    


    private String name;
    private transient int age;   // 属性将不被序列化
    private  boolean gender;

    public Person() {
    
        System.out.println("Person.Person");
    }

    public Person(String name, int age, boolean gender) {
    
        this.name = name;
        this.age = age;
        this.gender = gender;
        System.out.println("Person.Person.....");
    }

    @Override
    public String toString() {
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

package com.xxxx.dataStream;


import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

/**
 * 对象流
 */
public class Demo003ObjectOutputStream {
    
    public static void main(String[] args) throws IOException {
    

        // 节点流
        OutputStream os = new FileOutputStream("c.txt");
        // 处理流  对象流
        ObjectOutputStream oos = new ObjectOutputStream(os);
        // 写出对象
        oos.writeObject(new Person("zs",18,true));
        oos.flush();
        oos.close();
    }
}

运行结果

ObjectInputStream (反序列化)

package com.xxxx.dataStream;

import java.io.*;

/**
 * 创建对象的方式：
 * 1、new
 * 2、克隆
 * 3、反序列化--- 不走构造器
 */

public class Demo004ObjectInputStream {
    
    public static void main(String[] args) throws Exception {
    
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c.txt"));

        Person p = (Person)ois.readObject();
        System.out.println(p);
        ois.close();
    }
}
//运行结果
Person{
    name='zs', age=0, gender=true}

}

运行结果

[外链图片转存中…(img-QSPv6PpL-1627040042518)]

[外链图片转存中…(img-oyzfAp79-1627040042519)]

ObjectInputStream (反序列化)

package com.xxxx.dataStream;

import java.io.*;

/**
 * 创建对象的方式：
 * 1、new
 * 2、克隆
 * 3、反序列化--- 不走构造器
 */

public class Demo004ObjectInputStream {
    
    public static void main(String[] args) throws Exception {
    
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c.txt"));

        Person p = (Person)ois.readObject();
        System.out.println(p);
        ois.close();
    }
}
//运行结果
Person{
    name='zs', age=0, gender=true}