基本概念

  • IO就是Input和Output的简写，也就是输入和输出的含义。

  • IO流就是指读写数据时像流水一样从一端流到另外一端，因此得名为“流”

    基本分类

    按照读写数据的基本单位不同，分为 字节流 和 字符流。

  • 其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。

  • 其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件。

按照读写数据的方向不同，分为 输入流 和 输出流（站在程序的角度）。

  • 其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件。
  • 其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。

按照流的角色不同分为节点流和处理流。

  • 其中节点流主要指直接和输入输出源对接的流。
  • 其中处理流主要指需要建立在节点流的基础之上的流。

IO流 - 图1
IO流 - 图2

相关流—常用方法类似

FileWriter类

java.io.FileWriter类主要用于将文本内容写入到文本文件。
image.png

  1. package com.lagou.task17;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  6. /**
  7.  * @author lijing
  8.  * @date 2020/10/14 10:38
  9.  * @description
  10.  */
  11. public class FileWriterTest {
  12.     public static void main(String[] args) {
  13.         FileWriter fw= null;
  14.         try {
  15.             //1.构造FileWrite类型的对象与D:/atxt文件关联
  16.             //若文件不存在,会创新新文件
  17.             //若文件存在,该流会清空文件中原有内容
  18. //            fw = new FileWriter("D:/a.txt")
  19.             //已追加的方法创建对象去关联
  20.             fw=new FileWriter("D:/a.txt",true);
  22.             //2.通过流对象写入数据内容
  23.             fw.write('a');
  24.             //混呗一个字数组
  25.             char[] cArr=new char[]{'h','e','l','l','o'};
  26.             //将整个字符数组写入
  27.             fw.write(cArr,1,3);
  28.             fw.write(cArr);
  29.             //刷新流
  30.             fw.flush();
  31.             System.out.println("写入数据成功");
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }finally {
  36.             //3.关闭流对象并释放有关的资源
  37.             if(null!=fw){
  38.                 try {
  39.                     fw.close();
  40.                 } catch (IOException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.         }
  46.     }
  47. }

FileReader类

java.io.FileReader类主要用于从文本文件读取文本数据内容。
image.png

  1. package com.lagou.task17;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  6. /**
  7.  * @author lijing
  8.  * @date 2020/10/14 11:08
  9.  * @description
  10.  */
  11. public class FileReaderTest {
  12.     public static void main(String[] args) {
  13.         FileReader fr= null;
  14.         try {
  15.             //1.构造
  16.             fr = new FileReader("D:/a.txt");
  17.             //2.读取
  18.             /*int read = fr.read();
  19.             System.out.println("read-single-char:"+ ((char) read));*/
  20.             /*int res=0;
  21.             while((res=fr.read())!=-1){
  22.                 System.out.println("read-single-char:"+ ((char) res));
  23.             }*/
  24.             //准备一个字符数组来保存读取到的数据内容
  25.             char[] cArr=new char[5];
  26.             /*//期望读满字符数组中的一部分空间
  27.             int read = fr.read(cArr, 1, 3);
  28.             System.out.println("The actual number of reads is:"+ read);//3
  29.             for (char cv :cArr) {
  30.                 System.out.println("The actual single character read is:"+ ((char) cv));
  31.             }*/
  32.             //期望读满字符数组
  33.             int read=fr.read(cArr);
  34.             System.out.println("The actual number of reads is:"+ read);//5
  35.             for (char cv :cArr) {
  36.                 System.out.println("The actual single character read is:"+ ((char) cv));
  37.             }
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         } finally {
  41.             if (null!=fr){
  42.                 try {
  43.                     //3.关流
  44.                     fr.close();
  45.                 } catch (IOException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.         }
  51.     }
  52. }

FileOutputStream类

java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入到输出流中。
image.png

FileInputStream类

java.io.FileInputStream类主要用于从输入流中以字节流的方式读取图像数据等。
image.png

  1. package com.lagou.task17;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. /**
  8.  * @author lijing
  9.  * @date 2020/10/14 13:27
  10.  * @description
  11.  */
  12. public class FileByteCopyTest {
  13.     public static void main(String[] args) {
  15.         long g1 = System.currentTimeMillis();
  18.         FileInputStream fis = null;
  19.         FileOutputStream fos = null;
  20.         try {
  21.             //1.创建字节流输入输出的对象
  22. //            fis = new FileInputStream("D:/02总结.png");
  23. //            fos = new FileOutputStream("D:/总结.png");
  24.             fis = new FileInputStream("D:/navicat150_mysql_cs_x64.exe");
  25.             fos = new FileOutputStream("D:/1navicat150_mysql_cs_x64.exe");
  26.             //2.不断地从输入流总读取数据内容并写入到输出流中
  28.             System.out.println("Copying...");
  29.             //方式一:以单个字节为单位进行拷贝,也就是每次读取一个字节后在写入一个字节
  30.             //缺点:文件稍大时,拷贝的效率很低
  31.             /*int res=0;
  32.             while((res=fis.read())!=-1){
  33.                 fos.write(res);
  34.             }*/
  35.             //方式二:准备一个和文件大小一样的缓冲区,一次性将文件中的所有内容取出缓冲区然后一次性写入
  36.             //缺点:若文件过大时,无法申请和文件大小一样的缓冲区,真实物理内存不足
  37. //            int len=fis.available();
  38. //            System.out.println("gets the Bytes of the file:" + len);
  39. //            byte[] bArr = new byte[len];
  40. //            int res=fis.read(bArr);
  41. //            System.out.println("actual the bytes of the file:" + res);
  42. //            fos.write(bArr);
  43.             //方式三:准备一个相对适当的缓冲区,分多次将文件拷贝完成
  44.             byte[] bArr=new byte[1024];
  45.             int res=0;
  46.             while((res=(fis.read(bArr)))!=-1){
  47.                 fos.write(bArr,0,res);
  48.             }
  49.             System.out.println("Copy Completely");
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         } finally {
  53.             //3.关流
  54.             if(null!=fos){
  55.                 try {
  56.                     fos.close();
  57.                 } catch (IOException e) {
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.             if(null!=fis){
  62.                 try {
  63.                     fis.close();
  64.                 } catch (IOException e) {
  65.                     e.printStackTrace();
  66.                 }
  67.             }
  68.         }
  69.         long g2 = System.currentTimeMillis();
  70.         System.out.println("The time it takes to copy:" + (g2 - g1));
  71.     }
  72. }

BufferedOutputStream类

image.png
java.io.BufferedOutputStream类主要用于描述缓冲输出流，此时不用为写入的每个字节调用底层系统。

BufferedInputStream类

java.io.BufferedInputStream类主要用于描述缓冲输入流。
image.png

BufferedReader类

java.io.BufferedWriter类主要用于写入单个字符、字符数组以及字符串到输出流中。


BufferedWriter(Writer out)
根据参数指定的引用来构造对象

BufferedWriter(Writer out, int sz)
根据参数指定的引用和缓冲区大小来构造对象

void write(int c)
写入单个字符到输出流中

void write(char[] cbuf, int off, int
len)
将字符数组cbuf中从下标off开始的len个字符写入输出流中

void write(char[] cbuf)
将字符串数组cbuf中所有内容写入输出流中

void write(String s, int off, int len)
将参数s中下标从off开始的len个字符写入输出流中

void write(String str)
将参数指定的字符串内容写入输出流中

void newLine()
用于写入行分隔符到输出流中

void flush() 刷新流
void close() 关闭流对象并释放有关的资源		 
  1. package com.lagou.task17;
  3. import java.io.*;
  5. /**
  6.  * @author lijing
  7.  * @date 2020/10/14 13:50
  8.  * @description
  9.  */
  10. public class BufferedByteCopyTest {
  11.     public static void main(String[] args) {
  13.         long g1 = System.currentTimeMillis();
  15.         BufferedInputStream bis= null;
  16.         BufferedOutputStream bos= null;
  17.         try {
  18.             //1.创建BufferedInputStream类型的对象与文件关联
  19.             bis = new BufferedInputStream(new FileInputStream("D:/navicat150_mysql_cs_x64.exe"));
  20.             //2.创建BufferedOutputStream类型的对象与文件关联
  21.             bos = new BufferedOutputStream(new FileOutputStream("D:/1navicat150_mysql_cs_x64.exe"));
  22.             //3.拷贝
  23.             System.out.println("Copying...");
  24.             byte[] bArr=new byte[1024];
  25.             int res=0;
  26.             while((res=bis.read(bArr))!=-1){
  27.                 bos.write(bArr,0,res);
  28.             }
  29.             System.out.println("Copy Completely");
  30.         } catch (IOException e) {
  31.             e.printStackTrace();
  32.         } finally {
  33.             //4.关流
  34.             if (null!=bos){
  35.                 try {
  36.                     bos.close();
  37.                 } catch (IOException e) {
  38.                     e.printStackTrace();
  39.                 }
  40.             }
  41.             if(null!=bis){
  42.                 try {
  43.                     bis.close();
  44.                 } catch (IOException e) {
  45.                     e.printStackTrace();
  46.                 }
  47.             }
  48.         }
  49.         long g2 = System.currentTimeMillis();
  50.         System.out.println("The time it takes to copy:" + (g2 - g1));
  51.     }
  52. }

BufferedWriter类

java.io.BufferedReader类用于从输入流中读取单个字符、字符数组以及字符串。

printStream类

java.io.PrintStream类主要用于更加方便地打印各种数据内容。

  1. package com.lagou.task17;
  3. import java.io.*;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  7. /**
  8.  * @author lijing
  9.  * @date 2020/10/14 14:17
  10.  * @description
  11.  */
  12. public class PrintStreamTest {
  14.     public static void main(String[] args) {
  15.         BufferedReader br = null;
  16.         PrintStream ps = null;
  17.         try {
  18.             br = new BufferedReader(new InputStreamReader(System.in));
  19.             ps = new PrintStream(new FileOutputStream("d:/a.txt"));
  20.             //声明一个boolean类型的变量作为发送方的代表
  21.             boolean flag=true;
  22.             while(true) {
  23.                 //1.提示输入并使用变量记录
  24.                 System.out.println("Please enter what "+(flag?"张三":"李四")+" want to send:");
  25.                 //由手册可知,System.in代表键盘输入,而且是InputStream类型  字节流
  26.                 //BufferedReader要的参数是字符流,需要转换
  28.                 String str = br.readLine();
  29.                 //2.判断用户输入的内容是否为"bye",若是则结束
  30.                 if ("bye".equals(str)) {
  31.                     System.out.println("Contact Over!");
  32.                     break;
  33.                 }
  34.                 //3.否则 写入到文件d:/a.txt当中
  35.                 //获取当前系统时间并调整格式
  36.                 Date d1=new Date();
  37.                 SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  38.                 ps.println(sdf.format(d1)+(flag?"张三说:":"李四说:")+str);
  39.                 flag=!flag;
  40.             }
  41.         } catch (IOException e) {
  42.             e.printStackTrace();
  43.         } finally {
  44.             //4.关流
  45.             if(null!=ps){
  46.                 ps.close();
  47.             }
  48.             if(null!=br){
  49.                 try {
  50.                     br.close();
  51.                 } catch (IOException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.             }
  55.         }
  58.     }
  59. }

printWriter类

java.io.PrintWriter类主要用于将对象的格式化形式打印到文本输出流。

OutputStreamWriter类

java.io.OutputStreamWriter类主要用于实现从字符流到字节流的转换。


OutputStreamWriter(OutputStream out)
根据参数指定的引用来构造对象

OutputStreamWriter(OutputStream out, String charsetName)
根据参数指定的引用和编码构造对象

void write(String str)
将参数指定的字符串写入

void flush() 刷新流
void close() 用于关闭输出流并释放有关的资源

InputStreamReader类

java.io.InputStreamReader类主要用于实现从字节流到字符流的转换。

字节编码

计算机只能识别二进制数据，早期就是电信号。为了方便计算机可以识别各个国家的文字，就需要将各个国家的文字采用数字编号的方式进行描述并建立对应的关系表，该表就叫做编码表。

  • ASCII：美国标准信息交换码， 使用一个字节的低7位二位进制进行表示。
  • ISO8859-1：拉丁码表，欧洲码表，使用一个字节的8位二进制进行表示。
  • GB2312：中国的中文编码表，最多使用两个字节16位二进制为进行表示。
  • GBK：中国的中文编码表升级，融合了更多的中文文字符号，最多使用两个字节16位二进制位表示。
  • Unicode：国际标准码，融合了目前人类使用的所有字符，为每个字符分配唯一的字符码。所有的文字都用两个字节16位二进制位来表示。

编码的发展:

  • 面向传输的众多 UTF（UCS Transfer Format）标准出现了，UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码并使编码无国界，这样就可以显示全世界上所有文化的字符了。
  • Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8.UTF-16。
  • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

    DataOutputStream类

    java.io.DataOutputStream类主要用于以适当的方式将基本数据类型写入输出流中。

DataOutputStream(OutputStream out)
根据参数指定的引用构造对象OutputStream类是个抽象类，实参需要传递子类对象

void writeInt(int v)
用于将参数指定的整数一次性写入输出流,优先写入高字节

void close()
用于关闭文件输出流并释放有关的资源		 
  1. package com.lagou.task17;
  3. import java.io.DataOutputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. /**
  8.  * @author lijing
  9.  * @date 2020/10/14 15:05
  10.  * @description
  11.  */
  12. public class DataOutputStreamTest {
  13.     public static void main(String[] args) {
  14.         DataOutputStream dos = null;
  15.         try {
  16.             //1.创建dos类型的对象
  17.             dos = new DataOutputStream(new FileOutputStream("D:/a.txt"));
  18.             //2.准备整数数据并写入输出流
  19.             int num=66;
  20.             dos.writeInt(num);
  22.             System.out.println("写入数据成功");
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             //3.关流
  27.             if(null!=dos){
  29.                 try {
  30.                     dos.close();
  31.                 } catch (IOException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }
  36.     }
  37. }

DateInputStream类

java.io.DataInputStream类主要用于从输入流中读取基本数据类型的数据。

  1. package com.lagou.task17;
  3. import java.io.DataInputStream;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  7. /**
  8.  * @author lijing
  9.  * @date 2020/10/14 15:12
  10.  * @description
  11.  */
  12. public class DateInputStreamTest {
  13.     public static void main(String[] args) {
  14.         DataInputStream dis= null;
  15.         try {
  16.             //1.创建dis对象
  17.             dis = new DataInputStream(new FileInputStream("D:/a.txt"));
  18.             //2.从输入流读取整数并打印
  19.             int res=dis.readInt();
  20.             System.out.println("读取到的整数数据为:"+res);
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         } finally {
  24.             //3.关流
  25.             if(null!=dis){
  27.                 try {
  28.                     dis.close();
  29.                 } catch (IOException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.             }
  33.         }
  34.     }
  35. }

ObjectOutputStream类—需要序列化

  • java.io.ObjectOutputStream类主要用于将一个对象的所有内容整体写入到输出流中。
  • 只能将支持 java.io.Serializable 接口的对象写入流中。
  • 类通过实现 java.io.Serializable 接口以启用其序列化功能。
  • 所谓序列化主要指将一个对象需要存储的相关信息有效组织成字节序列的转化过程。
    |
    ObjectOutputStream(OutputStream out) |
    根据参数指定的引用来构造对象 | | —- | —- | |
    void writeObject(Object obj) |
    用于将参数指定的对象整体写入到输出流中 | |
    void close() |
    用于关闭输出流并释放有关的资源 |
  1. package com.lagou.task17;
  3. import java.io.Serializable;
  5. /**
  6.  * @author lijing
  7.  * @date 2020/10/14 15:24
  8.  * @description
  9.  */
  10. public class User implements Serializable {
  11.     private static final long serialVersionUID = -3543126975751553657L;
  12.     private String userName;
  13.     private String password;
  14.     private String phoneNum;
  16.     public User() {
  17.     }
  19.     public User(String userName, String password, String phoneNum) {
  20.         this.userName = userName;
  21.         this.password = password;
  22.         this.phoneNum = phoneNum;
  23.     }
  25.     public String getUserName() {
  26.         return userName;
  27.     }
  29.     public void setUserName(String userName) {
  30.         this.userName = userName;
  31.     }
  33.     public String getPassword() {
  34.         return password;
  35.     }
  37.     public void setPassword(String password) {
  38.         this.password = password;
  39.     }
  41.     public String getPhoneNum() {
  42.         return phoneNum;
  43.     }
  45.     public void setPhoneNum(String phoneNum) {
  46.         this.phoneNum = phoneNum;
  47.     }
  49.     @Override
  50.     public String toString() {
  51.         return "User{" +
  52.                 "userName='" + userName + '\'' +
  53.                 ", password='" + password + '\'' +
  54.                 ", phoneNum='" + phoneNum + '\'' +
  55.                 '}';
  56.     }
  57. }
  1. package com.lagou.task17;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.ObjectOutputStream;
  7. /**
  8.  * @author lijing
  9.  * @date 2020/10/14 15:25
  10.  * @description
  11.  */
  12. public class ObjectOutputStreamTest {
  13.     public static void main(String[] args) {
  14.         ObjectOutputStream oos= null;
  15.         try {
  16.             //1.创建对象
  17.             oos = new ObjectOutputStream(new FileOutputStream("D:/a.txt"));
  18.             //2.初始化User对象
  19.             User user=new User("name","pass","18815621");
  20.             //3.将User类型的对象写入输出流
  21.             oos.writeObject(user);
  22.             System.out.println("写入成功");
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             //4.关流
  27.             if(null!=oos){
  29.                 try {
  30.                     oos.close();
  31.                 } catch (IOException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }
  37.     }
  38. }

ObjectInputStream类

  • java.io.ObjectInputStream类主要用于从输入流中一次性将对象整体读取出来。
  • 所谓反序列化主要指将有效组织的字节序列恢复为一个对象及相关信息的转化过程。
    ```java package com.lagou.task17;

import java.io.FileInputStream; import java.io.IOException; import java.io.ObjectInputStream;

/**

  • @author lijing
  • @date 2020/10/14 15:55

  • @description */ public class ObjectInputStreamTest { public static void main(String[] args) {

    1.  ObjectInputStream ois= null;
    2.  try {
    3.      //1.ois
    4.      ois = new ObjectInputStream(new FileInputStream("D:/a.txt"));
    5.      //2.从输入流总读取一个对象并打印
    6.      Object obj = ois.readObject();
    7.      System.out.println("读取到的对象是:" + obj);
    8.  } catch (IOException e) {
    9.      e.printStackTrace();
    10.  } catch (ClassNotFoundException e) {
    11.      e.printStackTrace();
    12.  } finally {
    13.      //3.关流
    14.      if(null!=ois){
    16.          try {
    17.              ois.close();
    18.          } catch (IOException e) {
    19.              e.printStackTrace();
    20.          }
    21.      }
    22.  }

    } }

  1. **序列化版本号**<br />序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常<br />(InvalidCastException)。<br />**transient:**<br />transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。<br />**经验分享:**<br />当希望将多个对象写入文件时，通常建议将多个对象放入一个集合中，然后将集合这个整体看做一个对象写入输出流中，此时只需要调用一次readObject方法就可以将整个集合的数据读取出来，从而避免了通过返回值进行是否达到文件末尾的判断
  2. <a name="gpffW"></a>
  3. ### **RandomAccessFile类**
  4. java.io.RandomAccessFile类主要支持对随机访问文件的读写操作。
  6. | <br />RandomAccessFile(String name, String<br />mode) | <br />根据参数指定的名称和模式构造对象<br />r: 以只读方式打开<br />rw：打开以便读取和写入<br />rwd:打开以便读取和写入，同步文件内容的更新<br />rws:打开以便读取和写入，同步文件内容和元数据的更新 |
  7. | --- | --- |
  8. | <br />int read()  | <br />读取单个字节的数据 |
  9. | <br />void seek(long pos) | <br />用于设置从此文件的开头开始测量的文件指针偏移量 |
  10. | <br />void write(int b)  | <br />将参数指定的单个字节写入 |
  11. | <br />void close()  | <br />用于关闭流并释放有关的资源 |
  13. ```java
  14. package com.lagou.task17;
  16. import java.io.IOException;
  17. import java.io.RandomAccessFile;
  18. import java.util.RandomAccess;
  20. /**
  21.  * @author lijing
  22.  * @date 2020/10/14 16:06
  23.  * @description
  24.  */
  25. public class RandomAccessFileTest {
  26.     public static void main(String[] args) {
  27.         RandomAccessFile ra= null;
  28.         try {
  29.             //1.创建
  30.             ra = new RandomAccessFile("d:/a.txt","rw");
  31.             //2.对文件内容随机读写
  32.             //设置距离文件开头位置的偏移量,从文件开头位置向后偏移3个字节 aellhello
  33.             int read = ra.read();
  34.             System.out.println("读取到的单个字符为:"+(char)read);//l
  35.             read=ra.read();
  36.             System.out.println("读取到的单个字符为:"+(char)read);//l 指向了e
  37.             ra.write('2');//执行该行代码后覆盖了原来的'e'
  38.             System.out.println("写入成功");
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             //3.关流
  43.             if (null!=ra){
  45.                 try {
  46.                     ra.close();
  47.                 } catch (IOException e) {
  48.                     e.printStackTrace();
  49.                 }
  50.             }
  51.         }
  53.     }
  54. }