JavaSE模板化的IO流

IO流

​ 首先说明一下本章主要学什么，IO流，其实就是升级版的File文件操作，在本章通过学习一些流，调用相应的方法，就可以实现从程序到文件，再从文件到程序的相应操作，而这一章节的代码也比较模板化，因此只需要记住基本的流，基本的使用方法，具体应用可以在项目中进行实践。

一、流的三种分类方式

1.流向

输入流、输出流

2.数据单位

字节流、字符流

3.流的角色

节点流、处理流

二、流的结构体系

在这里只提供一些常用常见的流

这个表其实也不用记，看一眼，知道有啥东西就行了，重点在后边。

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
特殊流	DataInputStream	DataOutputStream

三、输入、输出的标准化过程

模板的输入输出过程我用文件的字节输入输出流演示

1.输入过程

①创建File类的对象，指明读取的数据的来源（要求此文件一定存在）

File srcFile = new File("d:\\zyb.jpg");

②创建相应的输入流，将File类的对象作为参数，传入流的构造器中

FileInputStream fis = new FileInputStream(srcFile);

③读入过程：创建相应的byte[]或char[],并调用fis的read方法，放入循环中

byte[]buffer=new byte[10];
int len=0;
while((len=fis.read(buffer))!=-1){
    System.out.println(new String(buf,0,len));
}

④关闭流资源

fis.close();

说明：程序中出现的异常需要使用try-catch-finally处理

2.输出过程

①创建File对象，指明写出数据的位置（不要求此文件一定要存在）

File destFile = new File("d:\\zyb2.jpg");

②创建相应的输出流，将File类的对象作为参数，传入流的构造器中

FileOutputStream fos = new FileOutputStream(destFile);

③写出(创建buffer数组和len指针变量的过程和输入过程相同)

fos.write(buffer,0,len);

④关闭流资源

fos.close();

四、节点流

1.FileReader(字符输入流)

说明点：1、read（）理解：返回读入的一个字符。如果到达文件末尾，则返回-1.

​ 2、异常处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally

​ 3、读入的文件一定要存在，否则会报FileNotFoundException异常

代码演示：

@Test
public void testFileReader1() throws IOException {

    //1.File类的实例化
    File file = new File("e:\\news2.txt");

    //2.FileReader流的实例化
    FileReader fileReader = new FileReader(file);

    //3.读入文件的操作
    //read(char[] cubf)：每次返回读入cubf数组中的字符个数，如果到达文件末尾，则返回-1
    char[]cbuf = new char[5];
    int len=0;
    while((len = fileReader.read(cbuf))!=-1){
        String str = new String(cbuf,0,len);
        System.out.println(str);
    }

    //4.资源的关闭
    fileReader.close();

}

2.FileWriter(字符输出流)

说明：1.输出到文件的操作，对应的File可以不存在，不会报异常

​ 2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。

​ File对应的硬盘中的文件如果存在：

​ 有两种构造器，如果流使用的构造器是FileWriter（file）/FileWriter（file，false）则写入的信息会对原文件进行覆盖，比如原文件中已经含有字符“hello”，而我使用writer写入“world”，则最后文件的内容只有“world”。

​ 如果流使用的构造器是**FileWriter（file，true）**那么进行的是对原文件的续写操作，不会进行覆盖。比如原文件中已经含有字符“hello”，我写入“world”，则最后文件的内容为“hello world”。

代码演示：

@Test
public void testFileWriter() throws IOException {
    
    //1.提供File类的对象，指明写出到的文件
    File file = new File("hello1.txt");
    
    //2.提供FileWriter的对象，用于数据的写出
    FileWriter fw = new FileWriter(file, false);
    
    //3.写出到文件操作
    fw.write("wu zi bu xing\n");
    fw.write("edg nb!");
    
    //4.流资源的关闭
    fw.close();
    
}

3.文本文件的复制

文本文件的复制操作是通过在一个程序中同时调用输入流和输出流，进而实现创建一个新的文本，并对其进行赋值。

代码如下：

其中，srcFile是被复制的文件，destFile是将要创建，进行复制的文件。

@Test
public void testFileReaderWriter() throws IOException {
    
    //1.创建File类的对象，指明读入和写出的文件
    File srcFile = new File("hello1.txt");
    File destFile = new File("hello2.txt");
    
    //2.创建输入流和输出流的对象
    FileReader fr = new FileReader(srcFile);
    FileWriter fw = new FileWriter(destFile);
    
    //3.数据的读入和写出操作
    char[] cubf = new char[5];
    int len;
    while((len=fr.read(cubf))!=-1){
        fw.write(cubf,0,len);
    }
    
    //4.关闭流
    fw.close();
    fr.close();
}

4.FileInputStream / FileOutputStream（字节流）

​ 呃，这个和上面的字符流一样，没什么好说的，代码模板都一样，只需要在写入写出的时候把char[]数组换成byte[]数组就行了。。。

​ 比较一下：对于文本文件（.txt,.java,.c,.cpp）之类的都使用字符流处理

​ 对于非文本文件（图片，音频，视频），使用字节流处理

五、缓冲流

1.缓冲流涉及到的类：

BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

2.作用

提高流的读取、写入速度

原理：内部提供了一个缓冲区。默认情况下是8kb

3.代码实现

·1BufferedInputStream、BufferedOutStream

该代码是用节点流+缓冲流实现图片的复制

其实缓冲流的代码跟上边节点流的代码模板一样，只不过多了一步将节点流的对象放入缓冲流的构造器中的步骤

@Test
public void BufferedStreamTest() throws IOException {
    
        //1.造文件
        File srcFile = new File("d:\\zyb.jpg");
        File destFile = new File("d:\\zyb2.jpg");

        //2.造节点流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        //3.造缓冲流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //4.复制：用bis读取，用bos写入
        byte[]buffer=new byte[10];
        int len=0;
        while((len=bis.read(buffer))!=-1) {
            bos.write(buffer, 0, len);
        }

        //5.资源关闭
        //要求：先关闭外层的流，再关闭内层的流
        bos.close();
        bis.close();
    }

·2BufferedReader、BufferedWriter

之前一直都是分开写，代码比较多，现在简写一下，试试将造文件的过程和造节点流的过程一起合并到造缓冲流的过程。

@Test
public void testBufferedReaderBufferedWriter() throws IOException {
    
        //1.将造文件，造节点流合成一步
        BufferedReader  bufferedReader = new BufferedReader(new FileReader(new File("e:\\news1.txt")));
        BufferedWriter   bufferedWriter = new BufferedWriter(new FileWriter(new File("e:\\news2.txt")));
       
        //2.数据的读入写出
        char[]cbuf=new char[1024];
        int len=0;
        while((len=bufferedReader.read(cbuf))!=-1){
            bufferedWriter.write(cbuf,0,len);
        }
        
        //3.关流
        bufferedReader.close();
        bufferedWriter.close();

    }

六、转换流

1.涉及到的类

InputStreamReader：将一个字节的输入流转换为字符的输入流

解码：字节、字节数组—>字符数组、字符串

OutputStreamWriter：将一个字符的输出流转换为字节的输出流

编码：字符数组、字符串—>字节、字节数组

编码决定解码!!!

2.作用

提供字节流的字符流之间的转换

3.代码实现

·InputStreamReader

将字节输入流转换为字符输出流

呃，其实就多加了一步将字节输入流的对象放到转换流的构造器中而已

//转换输入流
@Test
public void test1() throws IOException {
    
    FileInputStream fileInputStream = new FileInputStream("e:\\news1.txt");						           
    //参数“UTF-8”指明了字符集（根据文件初始存的时候决定）
    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");

    char[]cbuf=new char[1];
    int len;
    while((len=inputStreamReader.read(cbuf))!=-1){
        String str=new String(cbuf,0,len);
        System.out.print(str);
    }
    
    inputStreamReader.close();
}

·OutputStreamWriter

将字符输出流转换为字节输出流

写了这么多了，学了节点流，缓冲流，转换流，那现在咱们把这三个流都用到一起，综合升华一下，嘿嘿

这段代码的作用是实现文本的复制，就是将news1.txt中的文本信息复制到nesw3.txt中

快结束了，再来综合复习一下吧兄弟们

①造文件

②造节点流

③造缓冲流，提高运行效率

④造转换流，分别将输入流和输出流放入两个转换流中

⑤数组+循环 实现读入和写出

⑥关闭流

//转换输出流
@Test
public void test2() throws IOException{
	
    
    File file1 = new File("e:\\news1.txt");
    File file2 = new File("e:\\news3.txt");

    FileInputStream fileInputStream = new FileInputStream(file1);
    FileOutputStream fileOutputStream = new FileOutputStream(file2);
    
    BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
    BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"gbk");

    char[]cubf=new char[1];
    int len;
    while((len=inputStreamReader.read(cubf))!=-1){
        outputStreamWriter.write(cubf,0,len);
    }

    inputStreamReader.close();
    outputStreamWriter.close();
}

七、其它特殊流

1.标准的输入输出流

System.in：标准的输入流，默认从键盘输入 例如：new Scanner(System.in)

System.out：标准的输出流，默认从控制台输出 例如：System.out.println()

2.打印流

PrintStream和PrintWriter

说明：提供了一系列重载的print()和println()方法，用于多种数据类型的输出

​ System.out返回的是PrintStream的实例

3.数据流

DataInputStream和DataOutputStream

作用：用于读取或写出基本数据类型的变量或字符串

上面的三个流作为了解即可，不用深入

八、对象流

1.介绍

ObjectInputStream和ObjectOutputStream

作用：

ObjectInputStream：**内存中的对象—>存储中的文件、通过网络传输出去 ** 序列化过程

ObjectOutputStream：存储中的文件、通过网络接受过来—>内存中的对象 反序列化过程

2.对象的序列化机制

概念描述：

序列化过程：把内存中Java对象转换成平台无关的二进制流，从而把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。

反序列化过程：当其它程序获取了这种二进制流之后，就可以恢复成原来的Java对象

3.代码实现

序列化过程

​ 在这里说一点就是，java可以对自定义类进行序列化转换，但这个自定义类需要满足两个条件，第一个就是需要实现Serializable接口，这个接口是一个标识接口，不需要重写任何方法。第二个就是在类中需要提供一个全局常量serialVersionUID，其中这个全局常量的值必须进行自定义修改，任何值都可以。

•    * @author 一只鱼zzz
   
     * @version 1.0
   
       * Person类需要满足一下的要求，方可序列化
   
       * 1.需要实现接口：Serializable(标识接口，无需重写方法)
   
       * 2.当前类需要提供一个全局常量：serialVersionUID
         */
         public class Person implements Serializable {
   
          public static final long serialVersionUID = 1231213123132L;
   
          private String name;
          private int age;
   
       public Person(String name, int age) {
              this.name = name;
              this.age = age;
          }
   
          public String getName() {
              return name;
          }
       public void setName(String name) {
              this.name = name;
          }
   
          public int getAge() {
              return age;
          }
   
       public void setAge(int age) {
           this.age = age;
       }
   
       @Override
       public String toString() {
           return "Person{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   '}';
       }
       }
  

/*
序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
使用ObjectOutputStream实现
*/
@Test
public  void test1(){
   
       //1.造流造文件
       ObjectOutputStream oos = null;
   	try {
       oos = new ObjectOutputStream(new FileOutputStream("e:\\news1.dat"));
       //2.写
       oos.writeObject(new String("我爱轻大"));
       oos.flush();
       //3.刷新
       oos.writeObject(new Person("一只鱼zzzz",19));
       oos.flush();
   } catch (IOException e) {
       e.printStackTrace();
   } finally {
       //4.关
       try {
           oos.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

反序列化过程

@Test
public void  test2(){
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new FileInputStream("e:\\news1.dat"));

        Object obj=ois.readObject();
        String str=(String)obj;

        Person p = (Person) ois.readObject();

        System.out.println(p);
        System.out.println(str);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        try {
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

九、RandomAccessFile流

1.介绍

（1）该类直接继承于Object类，实现了DataInput和DataOutput接口

（2）既可以作为一个输入流，又可以作为一个输出流

（3）如果作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。如果写出到的文件存在，则会对原文件内容进行覆盖。（默认情况下，从头覆盖）

（4）通过相关的操作，可以实现RandomAccessFile“插入数据”的功能

2.典型代码1

@Test
public void test1() throws IOException {

    RandomAccessFile raf1 = new RandomAccessFile(new File("hello1.txt"), "r");
    RandomAccessFile raf2 = new RandomAccessFile(new File("hello3.txt"), "rw");
    
    byte[]buffer = new byte[1024];
    int len;
    while((len=raf1.read(buffer))!=-1){
        raf2.write(buffer,0,len);
    }

    raf2.close();
    raf1.close();
}

3.典型代码2（插入效果）

@Test
public void test2() throws IOException {

    RandomAccessFile raf1 = new RandomAccessFile("hello3.txt", "rw");

    raf1.seek(3);//将指针调节到角标为3的位置

    //保存指针3后面的所有数据到StringBuilder中
    StringBuilder builder = new StringBuilder((int) new File("hello3.txt").length());

    byte[] buffer = new byte[20];
    int len;
    while((len=raf1.read(buffer))!=-1){
        builder.append(new String(buffer,0,len));
    }

    //调回指针，写入“xyz”
    raf1.seek(3);
    raf1.write("xyz".getBytes());

    //将StringBuilder中的数据写入到文件中
    raf1.write(builder.toString().getBytes());

    raf1.close();
}