IO流

IO流概述和分类

I表示intput，是数据从硬盘进内存的过程，称之为读。
O表示output，是数据从内存到硬盘的过程。称之为写。

IO流的分类（一般IO流的分类是按照数据类型来分）

按流向分：

按数据类型分：

字节流

字节输出流（字节流写数据）

1、创建字节输出流对象
　　构造方法：
　　　　FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。
　　　　FileOutputStream(String name) 创建文件输出流以写入具有指定名称的文件。
　　　　　　如果文件不存在,会帮我们自动创建出来.
　　　　　　如果文件存在,会把文件清空.（如不想被清空，在第二个参数加true）

2、写数据
　　字节流写数据的3种方式：
　　　　void write​(int b) 一次写一个字节数据
　　　　void write​(byte[] b) 一次写一个字节数组数据
　　　　void write​(byte[] b, int off, int len) 一次写一个字节数组的部分数据。将从偏移量 off开始的指定字节数组中的 len字节写入此文件输出流。
3、释放资源
　　每次使用完流必须要释放资源。

public static void main(String[] args) throws IOException {
    //1.创建字节输出流的对象
    FileOutputStream fos = new FileOutputStream("D:\\a.txt"); //底层调用new File,所以使用该简写就可以
    //FileOutputStream fos = new FileOutputStream(new File("D:\\a.txt"));
    //2.写数据(写出的整数，实际写出的是整数在码表上对应的字母)
    //void write(int b)    一次写一个字节数据
    fos.write(97);
    fos.write(98);
    //void write(byte[] b)    一次写一个字节数组数据
    byte [] bys1 = {97,98,99};
    fos.write(bys1);
    //void write(byte[] b, int off, int len)    一次写一个字节数组的部分数据
    byte [] bys2 = {97,98,99,100,101,102,103};
    fos.write(bys2,1,2);
    //3.释放资源
    fos.close();
}

字节流写数据实现换行
　　写完数据后，加换行符
　　　　windows：\r\n
　　　　linux：\n
　　　　mac：\r
字节流写数据实现追加写入
　　public FileOutputStream​(String name，boolean append)
　　　　创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容

public static void main(String[] args) throws IOException {
    //第二个参数就是续写开关,如果没有传递,默认就是false,表示不打开续写功能,那么创建对象的这行代码会清空文件
    //如果第二个参数为true,表示打开续写功能,那么创建对象的这行代码不会清空文件
    FileOutputStream fos = new FileOutputStream("D:\\a.txt",true);

    fos.write(97);
    //加一个换行
    fos.write("\r\n".getBytes());
    fos.write(98);
    
    fos.close();
}

字节流写数据加try…catch异常处理
　　finally：在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源
　　　　特点：被finally控制的语句一定会执行，除非JVM退出
　　异常处理标准格式：try….catch…finally

public static void main(String[] args) {
    FileOutputStream fos = null;
    try {
        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();
            }
        }
    }
}

字节输入流（字节流读数据）

1、创建字节输入流对象
　　构造方法：
　　　　FileInputStream​(File file) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的 File对象 file命名。
　　　　FileInputStream​(String name) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的路径名 name命名。
　　　　　　如果文件不存在，就直接报错
2、读数据
　　int read() 从此输入流中读取一个字节的数据。
　　　　一次读取一个字节
　　　　　　返回值就是本次读到的那个字节数据。读出来的是文件中数据的码表值。 a->97。如果想要看到的是字符数据,要强转成char
　　　　读取多个字节
3、释放资源
　　每次使用完流必须要释放资源。

public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("bytestream\\a.txt");
    //一次读取一个字节
    int read = fis.read();
    System.out.println((char)read); //如果想看到字符数据,需要强转成char
    //读取多个字节
    int b;
    while ((b = fis.read())!=-1){
        System.out.println((char) b);
    }

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

提高拷贝速度的解决方案

为了解决速度问题，字节流通过创建字节数组，可以一次读写多个数据。
　　一次读一个字节数组的方法：
　　　　public int read(byte[] b)：从输入流读取最多b.length个字节的数据
　　　　返回的是读入缓冲区的总字节数,也就是实际的读取字节个数

public static void main(String[] args) throws IOException {
    //创建了字节输入流,准备读数据
    FileInputStream fis = new FileInputStream("C:\\a.avi");
    //创建了字节输出流,准备写数据
    FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");

    byte [] bytes = new byte[1024];
    int len; //本次读到的有效字节个数-这次读了几个字节
    while((len = fis.read(bytes))!=-1){
        fos.write(bytes,0,len);
    }
    fis.close();
    fos.close();
}

字节缓冲流

BufferedOutputStream：缓冲输出流
BufferedInputStream：缓冲输入流
构造方法：
字节缓冲输出流：BufferedOutputStream(OutputStream out)
字节缓冲输入流：BufferedInputStream(InputStream in)
　　字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

一次操作一个字节

public static void main(String[] args) throws IOException {
    //创建一个字节缓冲输入流
    //在底层创建了一个默认长度为8192的字节数组
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.txt"));
    //创建一个字节缓冲输出流
    //在底层也创建了一个默认长度为8192的字节数组
    BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("D:\\copy.txt"));

    int b;
    while((b=bis.read())!=-1){
        bos.write(b);
    }
    //方法的底层把字节流关闭
    bis.close();
    bos.close();
}

原理

内存中进行数据读写，内存运行速度非常快，减少了硬盘与内存数据的传递次数，从而提高性能。

一次操作一个字节数组

public static void main(String[] args) throws IOException {
    //创建一个字节缓冲输入流
    //在底层创建了一个默认长度为8192的字节数组
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.txt"));
    //创建一个字节缓冲输出流
    //在底层也创建了一个默认长度为8192的字节数组
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\copy.txt"));

    byte[] bytes = new byte[1024];
    int len;
    while ((len = bis.read(bytes)) != -1) {
        bos.write(bytes, 0, len);
    }
    //方法的底层把字节流关闭
    bis.close();
    bos.close();
}

原理：

字符流

字符串中的编码解码问题

windows默认使用码表为：GBK，一个字符两个字节。
idea和以后工作默认使用Unicode的UTF-8编解码格式，一个中文三个字节。

编码：
　　byte[] getBytes()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
　　byte[] getBytes(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
解码：
　　构造方法
　　　　String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String
　　　　String(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String

public static void main(String[] args) throws UnsupportedEncodingException {
        String s = "程序员";

        // byte[] getBytes()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
        //利用idea默认的UTF-8将中文编码为一系列的字节
        byte[] bytes1 = s.getBytes();
        System.out.println(Arrays.toString(bytes1)); //[-25, -88, -117, -27, -70, -113, -27, -111, -104]

        // byte[] getBytes(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
        byte[] bytes2 = s.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2)); //[-77, -52, -48, -14, -44, -79]

        // String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String
        byte [] bytes3 = {-25, -88, -117, -27, -70, -113, -27, -111, -104}; //UTF-8
        //利用默认的UTF-8进行解码
        String s1 = new String(bytes3);
        System.out.println(s1);//程序员

        // String(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String
        byte [] bytes4 = {-77, -52, -48, -14, -44, -79};  //gbk
        //利用指定的GBK进行解码
        String s2 = new String(bytes4,"gbk");
        System.out.println(s2);//程序员
    }

注：字节流一次读一个字节，不管GBK还是UTF-8一个中文都是多个字节，用字节流每次只能读其中的一部分，所以会出现乱码问题。

字符流读取中文的过程

1.字符流 = 字节流 + 编码表
2.不管是在哪张码表中，中文的第一个字节一定是负数。
3.想要进行拷贝，一律使用字节流或者字节缓冲流
4.想要把文件中的数据读到内存中打印或者读到内存中运算，请使用字符输入流。
5.想要把集合，数组，键盘录入等数据写到文件中，请使用字符输出流

字符流写数据

1、创建字符输出流对象。
　　FileWriter​(File file) 　　给 File写一个 FileWriter ，使用平台的 default charset
　　FileWriter​(String fileName) 　　构造一个 FileWriter给出文件名，使用平台的 default charset
　　　　如果文件不存在，就创建。但是要保证父级路径存在。
　　　　如果文件存在就清空。
2、写数据
　　void write​(int c) 　　写一个字符
　　void write​(char[] cbuf) 　　写入一个字符数组
　　void write​(char[] cbuf, int off, int len) 　　写入字符数组的一部分
　　void write​(String str) 　　写一个字符串
　　void write​(String str, int off, int len) 　　写一个字符串的一部分
　　　　写出int类型的整数，实际写出的是整数在码表上对应的字母。
　　　　写出字符串数据，是把字符串本身原样写出。
3、释放资源
　　每次使用完流必须要释放资源。

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

    //写出数据
    //void write(int c)            写一个字符
    fw.write(97);

    //void write(char[] cbuf)      写出一个字符数组
    char [] chars = {97,98,99,100,101};
    fw.write(chars);

    //void write(char[] cbuf, int off, int len)    写出字符数组的一部分
    char [] chars1 = {97,98,99,100,101};
    fw.write(chars1,0,3);

    //void write(String str)       写一个字符串
    String line = "程序员abc";
    fw.write(line);

    //void write(String str, int off, int len)     写一个字符串的一部分
    String line1 = "程序员abc";
    fw.write(line1,0,2);

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

flush和close方法

flush() 　　刷新流，刷新完毕之后，还可以继续写数据
close() 　　关闭流，释放资源。但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

public static void main(String[] args) throws IOException {
    FileWriter fw = new FileWriter("charstream\\a.txt");
    fw.write("程序员");
    //fw.flush();
    fw.write("666");

    fw.close();
    fw.write("aaa");//报错：Stream closed
}

字符流读数据

1、创建字符输入流对象。
　　FileReader​(File file) 　　使用平台FileReader ，在File读取时创建一个新的FileReader
　　FileReader​(String fileName) 　　使用平台default charset创建一个新的FileReader，给定要读取的文件的名称 。
2、读数据
int read() 　　一次读一个字符数据
int read(char[] cbuf) 　　一次读一个字符数组数据
3、释放资源
　　每次使用完流必须要释放资源。

public static void main(String[] args) throws IOException {
    //创建字符输入流的对象
    // FileReader fr = new FileReader(new File("charstream\\a.txt"));
    FileReader fr = new FileReader("charstream\\a.txt");

    //读取数据    
    //一次读取一个字符
    int ch;
    while((ch = fr.read()) != -1){
        System.out.println((char) ch);
    }
    
    //一次读取多个字符
    //创建一个数组
    char [] chars = new char[1024];
    int len;
    //read方法还是读取，但是是一次读取多个字符，把读到的字符都存入到chars数组。
    //返回值：表示本次读到了多少个字符。
    while((len = fr.read(chars))!=-1){
        System.out.println(new String(chars,0,len));
    }

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

字符缓冲流

BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途
构造方法：
　　BufferedWriter(Writer out)
　　BufferedReader(Reader in)

public static void main(String[] args) throws IOException {
    //字符缓冲输入流
    BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));

    //读取数据
    char [] chars = new char[1024];
    int len;
    while((len = br.read(chars)) != -1){
        System.out.println(new String(chars,0,len));
    }

    br.close();
}

public static void main(String[] args) throws IOException {
    //字符缓冲输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\a.txt"));

    //写出数据
    //实际写出的是97对应的字符a
    bw.write(97);
    bw.write("\r\n");

    //实际写出的是97 - 101 对应的字符 abcde
    char [] chars = {97,98,99,100,101};
    bw.write(chars);
    bw.write("\r\n");

    //实际写的是abc
    bw.write(chars,0,3);
    bw.write("\r\n");

    //会把字符串的内容原样写出
    bw.write("程序员");
    bw.write("\r\n");

    //会把字符串的一部分写出 abcde
    String line = "abcdefg";
    bw.write(line,0,5);

    bw.flush();

    bw.close();
}

字符缓冲流特有功能

BufferedWriter

void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义

public static void main(String[] args) throws IOException {
    //创建对象
    BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\a.txt"));
    //写出数据
    bw.write("程序员666");
    //跨平台的回车换行
    bw.newLine();
    bw.write("abcdef");
    //刷新流
    bw.flush();
    //释放资源
    bw.close();
}

BufferedReader

public String readLine() ：读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

public static void main(String[] args) throws IOException {
    //创建对象
    BufferedReader br = new BufferedReader(new FileReader("D:\\a.txt"));
    //使用循环来进行改进
    String line;
    //可以读取一整行数据。一直读，读到回车换行为止。不会读取回车换行符。
    while((line = br.readLine()) != null){
        System.out.println(line);
    }
    //释放资源
    br.close();
}

转换流

转换流就是来进行字节流和字符流之间转换的

InputStreamReader是从字节流到字符流的桥梁
OutputStreamWriter是从字符流到字节流的桥梁

在JDK11之前，指定编码读写

InputStreamReader​(InputStream in, String charsetName) 创建一个使用指定charset的InputStreamReader
OutputStreamWriter​(OutputStream out, String charsetName) 创建使用指定charset的OutputStreamWriter

public static void main(String[] args) throws IOException {
    //使用FileReader方法直接读取会产生乱码，因为文件是GBK码表，而idea默认的是UTF-8编码格式，两者不一致,导致乱码
    //FileReader fr = new FileReader("C:\\a.txt");
    InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\a.txt"),"gbk");
    int ch;
    while((ch = isr.read())!=-1){
        System.out.println((char) ch);
    }
    isr.close();

    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C:\\b.txt"),"UTF-8");
    osw.write("我爱学习");
    osw.close();
}

在JDK11之后，字符流新推出了一个构造

FileReader​(String fileName, Charset charset) 给定要读取的文件的名称和FileReader ，创建一个新的FileReader 。
FileWriter​(String fileName, Charset charset) 构造一个FileWriter给出文件名和charset 。

public static void main(String[] args) throws IOException {
    FileReader fr = new FileReader("C:\\a.txt", Charset.forName("gbk"));
    int ch;
    while ((ch = fr.read())!=-1){
        System.out.println((char) ch);
    }
    fr.close();
}

对象操作流

可以把对象以字节的形式写到本地文件，直接打开文件，是读不懂的，需要再次用对象操作流读到内存中。

 

对象操作输出流（对象序列化流）

就是将对象写到本地文件中，或者在网络中传输对象
ObjectOutputStream​(OutputStream out) 创建一个写入指定OutputStream的ObjectOutputStream。

如果想要这个类的对象能被序列化,那么这个类必须要实现一个接口：Serializable
　　Serializable 接口的意义:称之为是一个标记性接口,里面没有任何的抽象方法。只要一个类实现了这个Serializable接口,那么就表示这个类的对象可以被序列化.

public class User implements Serializable {
    private String username;
    private String password;
    public User() {
    }
    ...
}

public static void main(String[] args) throws IOException {
    User user = new User("zhangsan","qwer");
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
    oos.writeObject(user);
    oos.close();
}

对象操作输入流（对象反序列化流）

把写到本地文件中的对象读到内存中，或者接收网络中传输的对象
ObjectInputStream​(InputStream in) 创建一个从指定的InputStream读取的ObjectInputStream。

public static void main(String[] args) throws IOException, ClassNotFoundException {
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
    User o = (User) ois.readObject();
    System.out.println(o);
    ois.close();
}

对象操作流注意点

1、用对象序列化流序列化了一个对象后，如修改了对象所属的Javabean类，读取数据会抛出InvalidClassException异常
　　serialVersionUID 序列号：如果我们自己没有定义,那么虚拟机会根据类中的信息会自动的计算出一个序列号.
　　InvalidClassException异常问题：如果我们修改了类中的信息.那么虚拟机会再次计算出一个序列号.
　　　　第一步:把User对象序列化到本地.序列号为-5824992206458892149
　　　　第二步:修改了javabean类. 导致类中的序列号为4900133124572371851
　　　　第三步:把文件中的对象读到内存. 本地中的序列号和类中的序列号不一致了.
　　解决：不让虚拟机帮我们自动计算,我们自己手动给对象所属的类加一个serialVersionUID。而且这个值不要变.
　　　　private static final long serialVersionUID = 42L;

2、如果一个对象中的某个成员变量的值不想被序列化，需要给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程。

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private transient String password;

    public User() {
    }
    ...
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

用对象操作流读写多个对象

方式1：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    Student s1 = new Student("张三",16);
    Student s2 = new Student("李四",23);

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
    oos.writeObject(s1);
    oos.writeObject(s2);
    oos.close();
    
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
    Object obj;
    //ObjectInputStream到文件结束，会出现EOFException
    while(true){
       try {
           Object o = ois.readObject();
           System.out.println(o);
       } catch (EOFException e) {
           break;
       }
    }
    ois.close();
}

方式2：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    Student s1 = new Student("张三",16);
    Student s2 = new Student("李四",23);

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
    ArrayList<Student> list = new ArrayList<>();
    list.add(s1);
    list.add(s2);

    //在本地文件中写的就是一个集合
    oos.writeObject(list);
    oos.close();
    
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
    ArrayList<Student> list2 = (ArrayList<Student>) ois.readObject();
    for (Student student : list2) {
        System.out.println(student);
    }
    ois.close();
}

Properties（Map体系的集合类）

Properties中有跟IO相关的方法
Properties只存字符串

 Properties增删改查及遍历

public static void main(String[] args) {
    Properties prop = new Properties();
    //增
    prop.put("张三","18");
    prop.put("李四","19");
    prop.put("王五","23");
    System.out.println(prop);
    //删
    prop.remove("张三");
    System.out.println(prop);
    //改-put --- 如果键不存在,那么就添加,如果键存在,那么就覆盖.
    prop.put("张三","27");
    System.out.println(prop);
    //查
    Object value1 = prop.get("王五");
    System.out.println(value1);

    //遍历1
    Set<Object> keys = prop.keySet();
    for (Object key : keys) {
        Object value = prop.get(key);
        System.out.println(key + "=" + value);
    }
    //遍历2-装的是所有的键值对对象.
    Set<Map.Entry<Object, Object>> entries = prop.entrySet();
    for (Map.Entry<Object, Object> entry : entries) {
        Object key = entry.getKey();
        Object value = entry.getValue();
        System.out.println(key + "=" + value);
    }
}

 Properties作为集合的特有方法

Object setProperty(String key, String value) 　　设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
String getProperty(String key) 　　使用此属性列表中指定的键搜索属性
Set<String> stringPropertyNames() 　　从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

public static void main(String[] args) {
    //Object setProperty​(String key, String value) 设置集合的键和值，都是String类型，底层调用 Hashtable方法 put --- put
    Properties prop = new Properties();
    prop.setProperty("江苏","南京");
    prop.setProperty("山东","济南");
    System.out.println(prop); //{山东=济南, 江苏=南京}
    
    //String getProperty​(String key) 使用此属性列表中指定的键搜索属性 --- get
    String value = prop.getProperty("江苏");
    System.out.println(value);

    //Set<String> stringPropertyNames​() 从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串 --- keySet
    Set<String> keys = prop.stringPropertyNames();
    for (String key : keys) {
        String value = prop.getProperty(key);
        System.out.println(key + "=" + value);
    }
}

Properties和IO流结合的方法

void load(InputStream inStream) 　　从输入字节流读取属性列表（键和元素对）
void load(Reader reader) 　　从输入字符流读取属性列表（键和元素对）

public static void main(String[] args) throws IOException {
    //读取
    Properties prop = new Properties();
    FileReader fr = new FileReader("prop.properties");
    //调用完了load方法之后,文件中的键值对数据已经在集合中了.
    prop.load(fr);
    fr.close();
    System.out.println(prop);
}

void store(OutputStream out, String comments) 　　将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流
void store(Writer writer, String comments) 　　将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流
　　String comments：注释，内容会打印在文件的第一行

 

public static void main(String[] args) throws IOException {
    Properties prop = new Properties();
    prop.put("zhangsan","18");
    prop.put("lisi","23");
    FileWriter fw = new FileWriter("prop.properties");
    prop.store(fw,null);
    fw.close();
}