08 - JavaSE之IO流

2021-07-28 05:10:17

IO流

JAVA流式输入输出原理：可以想象成一根管道怼到文件上，另一端是我们程序，然后流的输入输出都是按照程序本身作为第一人称说明的。比如 input，对于我们程序来说就是有数据输入我们程序，output就是我们程序输出数据到文件等。对象不能搞错了，否则就南辕北辙了。

通过不同的角度对流的输入输出功能进行分类：

按数据流的方向分为：输入流和输出流
按处理数据单位不同分为：字节流和字符流（2个字节）
按功能不同分为：节点流和处理流

输入流和输出流

JAVA JDK 所提供的所有流类型位于包 java.io 内部，分别继承自下面四个抽象流类型：
```
	字节流         	字符流
```
输入流 InputStream Reader

输出流 OutputStream Writer

节点流和处理流

节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）。

节点流可以简单的理解为：一根管道直接怼到文件上，进行数据的读写。

处理流是连接在已存在的节点流或处理流上的，通过读数据进行处理（过滤等）为程序提供更加强大的读写功能。

处理流可以简单的理解为：套在节点流管道的管子，可以对流过节点流的数据进行处理，过滤等操作。

InputStream 抽象类

继承自 InputStream的流都是用于向程序中输入数据，且数据的单位为字节。
继承自 InputStream的类有如下等：（加粗为节点流，未加粗为处理流）

FileInputStream

PipedInputStream

FilterInputStream

ByteArrayInputStream

SequenceInputStream

StringBufferInputStream

ObjectInputStream

InputStream的基本方法

int read() throws IOException

int read(byte[] buffer) throws IOException

int read(byte[] buffer, int offset, int length) throws IOException

void close() throws IOException

OutputStream 抽象类

继承自 OutputStream的流都是用于从程序中输出数据，且数据的单位为字节。
继承自 OutputStream的类有如下等：（加粗为节点流，未加粗为处理流）

FileOutputStream

PipedOutputStream

FilterOutputStream

ByteArrayOutputStream

ObjectOutputStream

OutputStream 基本方法

void write(int b) throws IOException

void write(byte[] b) throws IOException

void write(byte[] b, int off, int len) throws IOException

void close() throws IOException

void flush() throws IOException // 在关闭输出流之前使用，将输出缓冲区的数据写到目的地

Reader

继承自 Reader 的流都是用于程序从外部读入数据，且数据的单位是字符（2个字节）。
如下为继承自Reader的流。（加粗为节点流，未加粗为处理流）

BufferedReader

CharArrayReader

InputStreamReader

FilterReader

PipedReader

StringReader

Reader的基本方法 - 略

Writer

继承自 Writer的流都是用于程序向外部写入数据，且数据的单位是字符（2个字节）。
如下为继承自Writer的流。（加粗为节点流，未加粗为处理流）

BufferedWriter

CharArrayWriter

OutputStreamWriter

FilterWriter

PipedWriter

StringWriter

Writer的基本方法 - 略

节点流类型

类型字节流字符流

File（文件） FileInputStream / FileOutputStream FileReader / FileWriter

Memory Array ByteArrayInputStream / ByteArrayOutputStream CharArrayReader / CharArrayWriter

Memory String -- StringReader / StringWriter

Pipe（管道） PipedInputStream / PipedOutputStream PipedReader / PipedWriter

举例1：FileInputStream

import java.io.*;

public class Test {

    public static void main(String[] args) {

        int b = 0;

        long num = 0;

        FileInputStream ln = null;

        try {

             ln = new FileInputStream("I:/Java/Demo/test.txt");

        } catch (FileNotFoundException e) {

            System.out.println("文件不存在！");

            System.exit(-1);

        }

        try {

            while ((b=ln.read()) != -1) {

                System.out.print((char)b);

                num++;

            }

            ln.close();

            System.out.println();

            System.out.println("共读出：" + num + "个字节。");

        } catch (IOException e) {

            System.out.println("文件读取失败！");

            System.exit(-1);

        }

    }

}

举例2：FileOutputStream

import java.io.*;

public class Test {

    public static void main(String[] args) {

        int b = 0;

        FileInputStream in = null;

        FileOutputStream out = null;

        try {

            in = new FileInputStream("I:/Java/Demo/test.txt");

            out = new FileOutputStream("I:/Java/Demo/newtest.txt");

            while((b=in.read()) != -1) {

                out.write(b);

            }

        } catch (FileNotFoundException e) {

            System.out.println("文件不存在！");

            System.exit(-1);

        } catch (IOException e) {

            System.out.println("文件复制失败！");

            System.exit(-2);

        }

        System.out.println("文件复制成功！");

    }

}

处理流类型

处理类型字节流字符流

Buffering BufferedInputStream/BufferedOutputStream BufferedReader/BufferedWriter

Filtering FilterInputStream/FilterOutputStream FilterReader/FilterWriter

Converting between bytes and character -- InputStreamReader/OutputStreamWriter

Object Serialization ObjectInputStream/ObjectOutputStream --

Data conversion DataInputStream/DataOutputStream --

Counting LineNumberInputStream LineNumberReader

Peeking ahead PushbackInputStream PushbackReader

Printing PrintStream PrintWriter

缓冲流（以Buffered开头）

缓冲流套接在相应的节点流上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。

BufferedReader / BufferedWriter / BufferedInputStream / BufferedOutputStream
缓冲流支持其父类的 mark 和 reset 方法。
BufferedReader 提供了 readLine 方法用于读取一行字符串（以\r或者\n分割）
BufferedWriter 提供了 newLine 用于写入一个行分隔符。
对于输出的缓冲流，写出的数据会先在内存中缓存，使用 flush 方法将会使内存中的数据立刻写出。

举例1：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        int b = 0;

        FileInputStream in = null;

        BufferedInputStream bin = null;

        try {

            in = new FileInputStream("I:/Java/Demo/test.txt");

            bin = new BufferedInputStream(in);

            bin.mark(100);

            for(int i=0; (i<=10)&&(b=bin.read()) != -1; i++) {

                System.out.print((char)b);

            }

            bin.reset();

            System.out.println();

            for(int i=0; (i<=10)&&(b=bin.read()) != -1; i++) {

                System.out.print((char)b);

            }

        } catch (FileNotFoundException e) {

            System.out.println("文件不存在！");

            System.exit(-1);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

举例2：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        String s = null;

        try {

            BufferedWriter bw = new BufferedWriter(new FileWriter("I:/Java/Demo/test.txt"));

            BufferedReader br = new BufferedReader(new FileReader("I:/Java/Demo/test.txt"));

            for(int i=0; i<100; i++) {

                s = Double.toString(Math.random());

                bw.write(s);

                bw.newLine();

            }

            bw.flush();

            while((s=br.readLine()) != null) {

                System.out.println(s);

            }

            bw.close();

            br.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

//0.7365309652822098

//0.577186775602007

//0.11736466966949166

//0.2998096440959087

//0.23859539950503672

//...

转换流

InputStreamReader 和 OutputStreamWriter 用于字节数据到字符数据之间的转换。
InputStreamReader 需要和 InputStream 套接。
OutputStreamWriter 需要和 OutputStream 套接。
转换流在构造时可以指定其编码结合，例如： InputStream is = new InputStreamReader(System.in, "ISO8859_1")

举例1：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        try {

            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("I:/Java/Demo/test.txt"));

            osw.write("1234567890");

            System.out.println(osw.getEncoding());

            osw.flush();

            osw.close();

            osw = new OutputStreamWriter(new FileOutputStream("I:/Java/Demo/test.txt", true), "ISO8859_1");

            osw.write("abcdefghijklmn");

            System.out.println(osw.getEncoding());

            osw.flush();

            osw.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

举例2：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        try {

            String s = null;

            InputStreamReader isr = new InputStreamReader(System.in);

            BufferedReader br = new BufferedReader(isr);

            while((s = br.readLine()) != null) {

                if(s.equalsIgnoreCase("exit")) {

                    break;

                }

                System.out.println(s);

            }

            br.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

数据流

DataInputStream 和 DataOutputStream 分别继承自 InputStream 和 OutputStream，它属于处理流，需要分别套接在 InputStream 和 OutputStream 类型的节点流上。
DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的 Java 原始类型数据（如：int，double 等）的方法。
DataInputStream 和 DataOutputStream 的构造方法为：

DataInputStream (InputStream in)

DataOutputStream (OutputStream out)

数据流的作用？

比如，我们如何存储一个很大的数到文件？我们之前的方法是将其转换成字符串存储，可不可以直接存储呢？数据流可以。它提供了很多方法用于存储基础数据类型的数据，参看 API 文档。

举例1：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 在内存自动生成一个 Byte[] 数组

        DataOutputStream dos = new DataOutputStream(baos);

        try {

            dos.writeDouble(Math.random());

            dos.writeBoolean(true);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

            System.out.println(bais.available());

            DataInputStream dis = new DataInputStream(bais);

            System.out.println(dis.readDouble());

            System.out.println(dis.readBoolean());

            dos.close();

            dis.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

问题：我们写一个 double，写一个boolean写到哪里了呢？

其实，在我们 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 的时候，就在内存中开辟了一块空间，用来将程序要写入的数据写到这片内存中。

还有，在读数据的时候，由于这片内存的分配是按照队列的方式分配的，所以先写进去的数据要先读出来，如果如上面程序那样，先读boolean的话，就会读取到double 8个字节的第一个字节上，切记！

Print 流（打印流）

PrintWriter 和 PrintStream 都属于输出流，分别针对与字符和字节。
PrintWriter 和 PrintStream 提供了重载的 print println 方法用于多种数据类型的输出。
PrintWriter 和 PrintStream 的输出操作不会抛出异常，用户通过检测错误状态获取错误信息。
PrintWriter 和 PrintStream 有自动 flush 功能。

PrintWriter(PrintWriter out)

PrintWriter(Writer out, boolean autoFlush)

PrintWriter(OutputStream out)

PrintWriter(OutputStream out, boolean autoFlush)

PrintStream(OutputStream out)

PrintStream(OutputStream out, boolean autoFlush)

举例1：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        PrintStream ps = null;

        try {

            FileOutputStream fos = new FileOutputStream("I:\\Java\\Demo\\test.txt");

            ps = new PrintStream(fos);

            if(null != ps) {

                System.setOut(ps);

            }

            for(int i=0; i<60000; i++) {

                System.out.print((char)i + " ");

                if(i%50 == 0) {

                    System.out.println();

                }

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

将输出打印语句重定向到 test.txt 文件中。

举例2：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        String filename = args[0];

        if (filename != null) {

            list(filename, System.out);

        }

    }

    public static void list(String f, PrintStream fs) {

        try {

            String s = null;

            BufferedReader br = new BufferedReader(new FileReader(f));

            while ((s = br.readLine()) != null) {

                fs.println(s);

            }

            br.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

将 args[0] 所写的文件名对应的文件打印到终端。

举例3：

import java.io.*;

import java.util.*;

public class Test {

    public static void main(String[] args) {

        String s = null;

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        try {

            FileWriter fw = new FileWriter("I:/Java/Demo/log.txt", true);

            PrintWriter log = new PrintWriter(fw);

            while((s=br.readLine()) != null) {

                if(s.equalsIgnoreCase("exit")) {

                    break;

                }

                System.out.println(s);

                log.println("------");

                log.println(s);

                log.flush(); // 可以省略

            }

            log.println("--- " + new Date() + " ---");

            log.flush(); // 可以省略

            log.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

将从终端输入的内容作为 log 写到 log.txt 文件里面。

Object 流

Object 流的作用：当我们存储一个元素的时候，（比如在画图软件上画了一个圆）我们的圆有很多属性，原点位置，半径大小，颜色，粗细等，既然每一个属性都需要存储，而且这些属性都在一个 Object 对象里面，那么我们为什么不直接写整个 Object呢？（这叫序列化。）

注意：当你 new 一个 Object 的时候，不单单只有你的属性，还有一些比如 Object的版本号，this，super 等。

举例：

import java.io.*;

public class Test {

    public static void main(String[] args) {

        TmpClass tm = new TmpClass();

        tm.a  =10;

        tm.d = false;

        try {

            FileOutputStream fos = new FileOutputStream("I:/Java/Demo/text.txt");

            ObjectOutputStream oos = new ObjectOutputStream(fos);

            oos.writeObject(tm);

            oos.flush();

            oos.close();

            FileInputStream fis = new FileInputStream("I:/Java/Demo/text.txt");

            ObjectInputStream ois = new ObjectInputStream(fis);

            TmpClass t = (TmpClass) ois.readObject();

            System.out.println(t.a + " " + t.b + " " + t.c + " " + t.d);

        } catch (ClassNotFoundException c) {

            System.out.println("读取文件失败");

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

class TmpClass implements Serializable {

    int a = 1;

    int b = 2;

    double c = 3.0;

    boolean d = true;

}

Serializable 接口

可以被序列化的，如果想把一个类的对象，写到硬盘或者网络，想把这个对象序列化成一个字节流的话，必须要实现这个接口。
这个接口没有任何方法，是一个空接口，是一个标记性接口，它只是给编译器看的，编译器看到后就知道这个类的对象时可以被序列化的，是可以整个写入文件的。

tansient关键字

使用方法，修饰成员变量。

class TmpClass implements Serializable {

    int a = 1;

    int b = 2;

    tansient double c = 3.0;

    boolean d = true;

}

transient 表示透明的意思，就是说在一个类的对象序列化的时候不予考虑，就是将这个类的对象写入文件的时候，不写这个被transient 修饰的成员变量，那么我们再读出来的时候就是默认值（如上，c 读出来的时候是 0.0）

externalizable 接口

可以理解为个性化的 Serializable 接口，externalizable 接口是继承 Serializable 接口得到的，相当于自己控制序列化的过程。（了解就好）

总结

本章复习方法：把所有的名字，关键字写到一张纸上，每天看看想想自己，给朕看半个时辰。—— 康熙

码农公寓

相关文章