08.File类与IO流

一、File 类

• 是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
  • Java 把电脑中的文件和文件夹(目录)封装为了一个 File 类。
• File 类是与系统无关的类，任何操作系统都可以使用这个类中的方法。
• 静态成员变量
• static  String  pathSeparator
  • 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
• static  char  pathSeparatorChar
• • • 与系统有关的路径分隔符。
  • File.pathSeparator 和 File.pathSeparatorChar 返回的结果相同。
    • 返回的是路径的分隔符。
    • windows
      • ;
      • 配置环境变量path中的 ;
    • Linux
      • :
  • static   String   separator
    
    • 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
  • static   char   separatorChar
    • 与系统有关的默认名称分隔符。
  • File.separator 和 File.separtorChar 返回的结果相同。
    • 返回的是文件名称分隔符。
    • windows
      • \
    • linux
      • /
    • 从这里可以看出项目中路径不能写死了。
• 路径
  • 绝对路径
    • 是一个完整路径，以盘符开始的路径。
    • C:\\Users\itcast\\IdeaProjects\\shungyuan\\123.txt
  • 相对路径
    • 是一个简化路径。
    • 相对指的是相对当前项目的根目录(C:\\Users\itcast\\IdeaProjects\\shungyuan)。
    • 路径可以写成：123.txt
  • 注意事项
    • 路径不区分大小写。
    • 路径中文件名称分隔符 windows 使用反斜杠。
    • 反斜杠是转义字符，两个反斜杠代表一个普通的反斜杠。
• 构造方法
  • File(String   pathname)
    • 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
    • 参数
      • String pathname：字符串的路径名称。
      • 路径可以是以文件结尾，也可以是以文件夹结尾。
      • 路径可以是相对路径，也可以是绝对路径。
      • 路径可以是存在，也可以是不存在。
      • 创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况。
  • File(String   parent, String   child)
    • 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    • 参数：把路径分成了两部分。
    • String parent：父路径。
    • String child：子路径。
    • 父路径和子路径，可以单独书写，使用起来非常灵活；父路径和子路径都可以变化。
  •  File(File   parent, String   child)
    • 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
    • 参数
      • 把路径分成了两部分。
      • File parent：父路径
      • String child：子路径
    • 父路径和子路径，可以单独书写，使用起来非常灵活；父路径和子路径都可以变化。
    • 父路径是 File 类型。可以使用 File 的方法对路径进行一些操作，再使用路径创建对象。
• 常用方法
  • public   String   getAbsolutePath()
    • 返回此 File 的绝对路径名字符串。
    • 无论构造方法中路径是绝对的还是相对的，getAbsolutePath 方法返回的都是绝对路径。
  • public   String   getPath()
    • 将此File转换为路径名字符串。
      • 对象的toString 方法调用的就是 getPath 方法。
  • public   String   getName()
    • 返回由此File表示的文件或目录的名称。
    • 获取的就是构造方法传递路径的结尾部分(文件或文件夹)。
  • public   long   length()
    • 返回由此 File 表示的文件的长度(大小，以字节为单位)。
      • 文件夹是没有大小概念的，不能获取文件夹的大小。
      • 如果构造方法中给出的路径不存在，那么 length 方法返回 0 。
• 判断功能的方法
  • public   boolean   exists()
    • 判断此 File 表示的文件或目录是否实际存在。
      • 存在：true；不存在：false 。
  • public   boolean   isDirectory()
    
    • 判断构造方法中给定的路径是否以文件夹结尾。
      • 是：true ; 否：false 。
  • public   boolean   isFile()
    • 判断构造方法中给定的路径是否以文件结尾。
      • 是：true；否：false 。
  • 注意事项
    • 电脑的硬盘中只有文件/文件夹，两个方法是互斥。
    • 这两个方法使用前提，路径必须是存在的，否则都返回 false 。
• 创建删除功能的方法
  • public   boolean   createNewFile()
    • 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件，创建文件的路径和名称在构造方法中给出(构造方法的参数)。
    • 返回值：布尔值。
      • true：文件不存在，创建文件，返回 true 。
      • false：文件存在，不会创建，返回 false 。
      • 注意事项
        • 此方法只能创建文件，不能创建文件夹。
        • 创建文件的路径必须存在，否则会抛出异常。
  • public   boolean   delete()
    • 删除构造方法路径中给出的文件/文件夹。
    • 返回值：布尔值。
      • true：文件/文件夹删除成功，返回 true 。
      • false：文件夹中有内容，不会删除，返回false；构造方法中路径不存在 false 。
      • 注意事项
        • 该方法是直接在硬盘删除文件/文件夹，不走回收站，删除要谨慎。
  • public   boolean   mkdir()
    • 创建单级空文件夹。
  • public   boolean   mkdirs()
    • 既可以创建单级空文件夹，也可以创建多级文件夹。
  • 上面这两个方法的返回值：布尔值。
    • true：文件夹不存在，创建文件夹，返回 true 。
    • false：文件夹存在，不会创建，返回false；构造方法中给出的路径不存在返回 false 。
    • 注意事项
      • 此方法只能创建文件夹，不能创建文件。
• 遍历目录
  • public   String[]   list()
    • 遍历构造方法中给出的目录，会获取目录中所有文件/文件夹的名称，把获取到的多个名称存储到一个 String 类型的数组中。
  • public   File[]   listFiles()
    • 遍历构造方法中给出的目录，会获取目录中所有的文件/文件夹，把文件/文件夹封装为 File 对象，多个 File 对象存储到 File 数组中。
  • 注意事项
    • list 方法和 listFiles 方法遍历的是构造方法中给出的目录。
    • 如果构造方法中给出的目录的路径不存在，会抛出空指针异常。
    • 如果构造方法中给出的路径不是一个目录，也会抛出空指针异常。

二、递归

• 递归：指在当前方法内调用自己的这种现象。
• 递归的分类
  • 递归分为两种，直接递归和间接递归。
    • 直接递归：方法自身调用自己。
    • 间接递归：A 方法调用 B 方法，B 方法调用 C 方法，C 方法调用 A 方法。
• 注意事项
  • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
  • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
  • 构造方法，禁止递归。
• 递归的使用前提
  • 当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归。

三、IO 概述

• 数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入 input 和 输出 output，即流向内存是输入流，流出内存的输出流。
• IO 分类
  • 根据数据的流向分为：输入流和输出流。
    • 输入流 ：把数据从其他设备上读取到内存中的流。
    • 输出流 ：把数据从内存中写出到其他设备上的流。
  • 根据数据的类型分为：字节流和字符流。
    • 字节流 ：以字节为单位，读写数据的流。
    • 字符流 ：以字符为单位，读写数据的流。

四、字节流

• 一切皆为字节
  • 一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
• OutputStream
  • 字节输出流。
  • 此抽象类是表示输出字节流的所有类的超类。
  • 共性方法
    • public   void   close()
      • 关闭此输出流并释放与此流相关联的任何系统资源。
    • public   void   flush()
      • 刷新此输出流并强制任何缓冲的输出字节被写出。
    • public   void   write(byte[]   b)
      • 将 b.length字节从指定的字节数组写入此输出流。
    • public   void   write(byte[]   b, int   off, int   len)
      • 从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
    • public   abstract   void write(int   b)
      • 将指定的字节输出流。
• FileOutputStream
  • 文件字节输出流.
  • 作用
    • 把内存中的数据写入到硬盘的文件中。
  • 构造方法
    • FileOutputStream(String   name)
      • 创建一个向具有指定名称的文件中写入数据的输出文件流。
    • FileOutputStream(File   file)
      • 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    • 以上两个构造方法
      • 参数：写入数据的目的地。
      • String name：目的地是一个文件的路径。
      • File file：目的地是一个文件。
    • 构造方法的作用
      • 创建一个 FileOutputStream 对象。
      • 会根据构造方法中传递的文件/文件路径，创建一个空的文件。
      • 会把 FileOutputStream 对象指向创建好的文件。
    • 写入的原理(内存 --> 硬盘)
      • java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中
    • 字节输出流的使用步骤(重点)
      • 创建一个 FileOutputStream 对象，构造方法中传递写入数据的目的地。
        
      • 调用 FileOutputStream 对象中的方法 write ，把数据写入到文件中。
      • 释放资源(流使用会占用一定的内存，使用完毕要把内存清空，提供程序的效率)。
    • 追加写/续写：使用两个参数的构造方法
      • FileOutputStream(String   name, boolean   append)
        • 创建一个向具有指定 name 的文件中写入数据的输出文件流。
      • FileOutputStream(File   file, boolean   append)
        • 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
      • 以上两个构造方法
        • 参数
          • String name，File file：写入数据的目的地。
          • boolean append：追加写开关。
            • true：创建对象不会覆盖源文件，继续在文件的末尾追加写数据。
            • false：创建一个新文件，覆盖源文件。
    • 换行写：写换行符号
      • windows：\r\n
      • linux：/n
  • 常用方法
    • void   write(int   b)
      • 每次可以写出一个字节数据。
    • void   write(byte[]  b)
      • 将 b.length 字节从指定的字节数组写入此输出流。
        • 如果写的第一个字节是正数(0-127)，那么显示的时候会查询 ASCII 表。
        • 如果写的第一个字节是负数，那第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认码表 (GBK)。
    • void   write(byte[]   b, int   off, int   len)
      • 从指定的字节数组写入 len字节，从偏移量 off 开始输出到此输出流。
        • 参数
          • int off：数组的开始索引。
          • int len：写几个字节。
• InputStream
  • 字节输入流
  • 此抽象类是表示字节输入流的所有类的超类。
  • 共性方法
    • int   read()
      • 读取文件中的一个字节并返回，读取到文件的末尾返回 -1。
    • int   read(byte[]   b) 
      • 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
    • void   close()
      • 关闭此输入流并释放与该流关联的所有系统资源。
• FileInputStream
  • 作用
    • 把硬盘文件中的数据，读取到内存中使用。
  • 构造方法
    • FileInputStream(String   name)
    • FileInputStream(File   file)
    • 以上两个构造方法
      
      • 参数：读取文件的数据源。
      • String name：文件的路径
      • File file：文件
    • 构造方法作用
      • 会创建一个 FileInputStream 对象。
      • 会在 FileInputStream 对象指定构造方法中要读取的文件。
    • 读取数据的原理(硬盘-->内存)
      • java 程序 --> JVM --> OS --> OS 读取数据的方法 --> 读取文件
    • 字节输入流的使用步骤(重点)
      • 创建 FileInputStream 对象，构造方法中绑定要读取的数据源。
      • 使用 FileInputStream 对象中的方法 read ，读取文件。
      • 释放资源。
    • 常用方法
      • int   read(byte[]   b)
        • 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
      • 明确两件事情
        • 方法的参数 byte[] 的作用?
          • 起到缓冲作用，存储每次读取到的多个字节。
          • 数组的长度一把定义为 1024(1kb) 或者 1024 的整数倍。
        • 方法的返回值 int 是什么?
          • 每次读取的有效字节个数
      • 读取是一个重复的过程，可以使用循环优化，使用 while 循环，循环结束的条件，读取到 -1 为止。
    • 文件的复制
      • 使用数组读取，每次读取多个字节，减少了系统间的 IO 操作次数，从而提高了读写的效率，建议开发中使用。
        • byte[]   bytes = new   byte[1024];
      • 步骤
        • 创建一个字节输入流对象，构造方法中绑定要读取的数据源。
        • 创建一个字节输出流对象，构造方法中绑定要写入的目的地。
        • 使用字节输入流对象中的方法 read(byte[] b)  读取文件。
        • 使用字节输出流中的方法 write(byte[] b, int off, int len) ，把读取到的字节写入到目的地的文件中。
        • 释放资源。

五、字符流

• java.io.Reader
  • 字符输入流，是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类。
  • 共性方法
    • int   read()
      • 读取单个字符并返回。
    • int   read(char[]   cbuf)
      • 一次读取多个字符，将字符读入数组。
    • void   close()
      • 关闭该流并释放与之关联的所有资源。
• FileReader
  • 文件字符输入流
  • 作用：把硬盘文件中的数据以字符的方式读取到内存中。
  • 构造方法
    • FileReader(String   fileName)
    • FileReader(File   file)
    • 以上两个构造方法
      • 参数：读取文件的数据源
        • String fileName：文件的路径。
        • File file：一个文件。
    • 构造方法的作用
      • 创建一个 FileReader 对象。
      • 会把 FileReader 对象指向要读取的文件。
    • 字符输入流使用步骤
      • 创建 FileReader 对象，构造方法中绑定要读取的数据源。
      • 使用 FileReader 对象中的方法 read 读取文件。
      • 释放资源
• java.io.Writer
  • 字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类。
  • 共性方法
    • void   write(int   c)
      • 写入单个字符。
    • void   write(char[]   cbuf)
      • 写入字符数组。
    • abstract   void   write(char[]   cbuf, int   off, int   len)
      • 写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
    • void   write(String   str)
      • 写入字符串。
    • void   write(String   str, int   off, int   len)
      • 写入字符串的某一部分，off 字符串的开始索引，len 写的字符个数。
    • void   flush()
      • 刷新该流的缓冲。
    • void   close()
      • 关闭此流，但要先刷新它。
• FileWrite
  • 文件字符输出流.
  • 作用：把内存中字符数据写入到文件中。
  • 构造方法
    • FileWriter(File   file)
    • FileWriter(String   fileName)
    • 以上两个构造方法
      • 参数：写入数据的目的地。
      • String fileName：文件的路径。
      • File file：是一个文件。
    • 构造方法的作用
      • 会创建一个 FileWriter 对象。
      • 会根据构造方法中传递的文件/文件的路径，创建文件。
      • 会把 FileWriter 对象指向创建好的文件。
    • 字符输出流的使用步骤(重点):
      • 创建 FileWriter 对象，构造方法中绑定要写入数据的目的地。
      • 使用 FileWriter 中的方法 write，把数据写入到内存缓冲区中(字符转换为字节的过程)。
      • 使用 FileWriter 中的方法 flush，把内存缓冲区中的数据，刷新到文件中。
      • 释放资源(会先把内存缓冲区中的数据刷新到文件中)。
    • flush 方法和 close 方法的区别
      • flush：刷新缓冲区，流对象可以继续使用。
      • close：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
    • 追加写/续写：使用两个参数的构造方法
      • FileWriter(String   fileName, boolean   append)
      • FileWriter(File   file, boolean   append)
        • 参数
          • String fileName，File file：写入数据的目的地。
          • boolean append：续写开关。
            • true：不会创建新的文件覆盖源文件，可以续写。
            • false：创建新的文件覆盖源文件。
  • 常用方法
    • void   write(char[]   cbuf)
      • 写入字符数组。
    • abstract  void   write(char[]   cbuf, int   off, int   len)
      • 写入字符数组的某一部分，off数组的开始索引，len写的字符个数。
    • void   write(String   str)
      • 写入字符串。
    • void   write(String   str, int   off, int   len)
      • 写入字符串的某一部分，off 字符串的开始索引，len 写的字符个数。

六、IO 异常的处理

• JDK 7 以前
  • 使用 try...catch...finally
    • 流对象定义在 try 之前，提高变量作用域，让 finally 可以使用。
    • try 中对流对象赋值。
    • finally 中先对流对象进行非 null 检验，再 close 。
• JDK 7 处理
  • 使用 try()...catch
    • try 后面加一个 ()，再括号中定义流对象并赋值。
      • 流对象有多个中间用 ; 分隔，最后的流对象后也有 ;。
    • 流对象的作用域在 try 中有效。
    • try 中代码执行完毕后，会自动释放流对象，不用写 finally 。
• JDK 9 处理
  • 使用 try()...catch
    • try 的前边可以定义流对象并赋值。
    • 在 try 后边的 () 中可以直接引入流对象的名称(变量名)。
      • 有多个变量名中间用 ; 分隔，最后一个变量名后没有 ; 。
    • try 代码执行完毕后，会自动释放流对象，不用写 finally 。

七、缓冲流

• 缓冲流，也叫高效流，是对 4 个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类
  • 字节缓冲流
    • BufferedInputStream，BufferedOutputStream
  • 字符缓冲流
    • BufferedReader，BufferedWriter
• 缓冲流的基本原理
  • 在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统 IO 次数，从而提高读写的效率。
• BufferedOutputStream
  • extends OutputStream
  • 字节缓冲输出流。
  • 构造方法
    • BufferedOutputStream(OutputStream   out)
      • 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
    • BufferedOutputStream(OutputStream   out, int   size)
      • 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
    • 参数
      • OutputStream out：字节输出流。
        • 我们可以传递 FileOutputStream，缓冲流会给 FileOutputStream 增加一个缓冲区，提高 FileOutputStream 的写入效率。
      • int size：指定缓冲流内部缓冲区的大小，不指定默认。
  • 使用步骤(重点)
    • 创建 FileOutputStream 对象，构造方法中绑定要输出的目的地。
    • 创建 BufferedOutputStream 对象，构造方法中传递 FileOutputStream 对象，提高 FileOutputStream 对象效率。
    • 使用 BufferedOutputStream 对象中的方法 write，把数据写入到内部缓冲区中。
    • 使用 BufferedOutputStream 对象中的方法 flush，把内部缓冲区中的数据刷新到文件中。
    • 释放资源(会先调用 flush 方法刷新数据，第4部可以省略)
• BufferedInputStream
  • extends InputStream
  • 字节缓冲输入流
  • 构造方法
    • BufferedInputStream(InputStream   in)
      • 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
    • BufferedInputStream(InputStream   in, int   size)
      • 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
    • 参数
      • InputStream in：字节输入流。
        • 我们可以传递 FileInputStream，缓冲流会给 FileInputStream 增加一个缓冲区，提高 FileInputStream 的读取效率。
        • int size：指定缓冲流内部缓冲区的大小，不指定默认。
  • 使用步骤(重点)
    • 创建 FileInputStream 对象，构造方法中绑定要读取的数据源。
    • 创建 BufferedInputStream 对象，构造方法中传递 FileInputStream 对象，提高 FileInputStream 对象的读取效率。
    • 使用 BufferedInputStream 对象中的方法 read，读取文件。
    • 释放资源。
• BufferedWriter
  • extends Writer
  • 字符缓冲输出流。
  • 构造方法
    • BufferedWriter(Writer   out)
      • 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
    • BufferedWriter(Writer   out, int   size) 
      • 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
    • 参数
      • Writer out：字符输出流。
      • 我们可以传递 FileWriter，缓冲流会给 FileWriter 增加一个缓冲区，提高 FileWriter 的写入效率。
    • int size：指定缓冲区的大小，不写默认大小。
  • 特有的成员方法
    • void   newLine()
      • 写入一个行分隔符。会根据不同的操作系统，获取不同的行分隔符。
  • 使用步骤
    • 创建字符缓冲输出流对象，构造方法中传递字符输出流。
    • 调用字符缓冲输出流中的方法 write，把数据写入到内存缓冲区中。
    • 调用字符缓冲输出流中的方法 flush，把内存缓冲区中的数据，刷新到文件中。
    • 释放资源。
• BufferedReader
  • extends Reader
  • 字符缓冲输入流。
  • 构造方法
    • BufferedReader(Reader   in)
      • 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
    • BufferedReader(Reader   in, int   size)
      • 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
    • 参数
      • Reader in：字符输入流。
        • 我们可以传递 FileReader，缓冲流会给 FileReader 增加一个缓冲区，提高 FileReader 的读取效率。
      • int size：指定缓冲流内部缓冲区的大小，不指定默认。
  • 特有的成员方法
    • String   readLine()
      • 读取一个文本行，读取一行数据。
        • 行的终止符号：通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行 (\r\n)。
      • 返回值
        • 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null 。
  • 使用步骤
    • 创建字符缓冲输入流对象，构造方法中传递字符输入流。
    • 使用字符缓冲输入流对象中的方法 read/readLine 读取文本。
    • 释放资源。

八、转换流

• 字符编码和字符集
  • 计算机中储存的信息都是用二进制数表示的。
  • 编码：按照某种规则，将字符存储到计算机中。
  • 解码：将存储在计算机中的二进制数按照某种规则解析显示出来。
• 字符编码
  • 就是一套自然语言的字符与二进制数之间的对应规则。
• 字符集
  • 也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
• 编码引出的问题
  • • 在IDEA中，使用 FileReader 读取项目中的文本文件。由于IDEA的设置，都是 UTF-8 编码，所以没有任何问题。但是，当读取 Windows 系统中创建的文本时，由于 Windows 默认是 GBK 编码，就会出现乱码。
• OutputStreamWriter
  • extends Writer
  • 是字符流通向字节流的桥梁。
  • 可使用指定的 charset 将要写入流中的字符编码成字节
  • 构造方法
    • OutputStreamWriter(OutputStream   out)
      • 创建使用默认字符编码的 OutputStreamWriter。
    • OutputStreamWriter(OutputStream   out, String   charsetName)
      • 创建使用指定字符集的 OutputStreamWriter。
    • 参数
      
      • OutputStream out：字节输出流，可以用来写转换之后的字节到文件中。
      • String charsetName：指定的编码表名称，不区分大小写，可以是utf-8/UTF-8，gbk/GBK，...不指定默认使用UTF-8。
  • 使用步骤
    • 创建 OutputStreamWriter 对象,构造方法中传递字节输出流和指定的编码表名称。
    • 使用 OutputStreamWriter 对象中的方法 write，把字符转换为字节存储缓冲区中(编码)。
    • 使用 OutputStreamWriter 对象中的方法 flush，把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)。
    • 释放资源。
• InputStreamReader
  • extends Reader
  • 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。
  • 构造方法
    • InputStreamReader(InputStream   in)
      • 创建一个使用默认字符集的 InputStreamReader。
    • InputStreamReader(InputStream   in, String   charsetName)
      • 创建使用指定字符集的 InputStreamReader。
    • 参数
      • InputStream in：字节输入流，用来读取文件中保存的字节。
      • String charsetName：指定的编码表名称，不区分大小写，可以是 utf-8/UTF-8，gbk/GBK，...不指定默认使用UTF-8。
  • 使用步骤
    • 创建 InputStreamReader 对象，构造方法中传递字节输入流和指定的编码表名称。
    • 使用 InputStreamReader 对象中的方法 read 读取文件。
    • 释放资源。
  • 注意事项
    • 构造方法中指定的编码表名称要和文件的编码相同，否则会发生乱码。

九、序列化

• Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。

　　

• ObjectOutputStream
  • extends OutputStream
  • 对象的序列化流，把对象以流的方式写入到文件中保存。
  • 构造方法
    • ObjectOutputStream(OutputStream   out)
      • 创建写入指定 OutputStream 的 ObjectOutputStream。
    • 参数
      • OutputStream out：字节输出流。
  • 特有的成员方法
    • void writeObject(Object   obj)
      • 将指定的对象写入 ObjectOutputStream。
  • 使用步骤
    • 创建 ObjectOutputStream 对象，构造方法中传递字节输出流。
    • 使用 ObjectOutputStream 对象中的方法 writeObject，把对象写入到文件中。
    • 释放资源。
• ObjectInputStream
  • extends InputStream
  • 反序列化流，将之前使用 ObjectOutputStream 序列化的原始数据恢复为对象。
  • 构造方法
    • ObjectInputStream(InputStream   in)
      • 创建从指定 InputStream 读取的 ObjectInputStream。
      • 参数
        • InputStream in：字节输入流。
  • 特有的成员方法
    • Object   readObject()
      • 从 ObjectInputStream 读取对象。
  • 使用步骤
    • 创建 ObjectInputStream 对象,构造方法中传递字节输入流。
    • 使用 ObjectInputStream 对象中的方法 readObject 读取保存对象的文件。
    • 释放资源。
    • 使用读取出来的对象(打印)。
  • 反序列化的前提
    • 类必须实现 Serializable
    • 必须存在类对应的 class 文件。
      • readObject方法声明抛出了ClassNotFoundException(class文件找不到异常)。

十、打印流

• PrintStream
  • extends OutputStream
  • 打印流。
  • 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
• 特点
  • 只负责数据的输出，不负责数据的读取。
  • 与其他输出流不同，PrintStream 永远不会抛出 IOException。
  • 有特有的方法：print，println 。
    • void   print(任意类型的值)。
    • void   println(任意类型的值并换行)
• 构造方法
  • PrintStream(File   file)
    • 输出的目的地是一个文件。
  • PrintStream(OutputStream   out)
    • 输出的目的地是一个字节输出流。
  • PrintStream(String   fileName)
    • 输出的目的地是一个文件路径。
• 注意事项
  • 如果使用继承自父类的 write 方法写数据，那么查看数据的时候会查询编码表。 97->a　　
  • 如果使用自己特有的方法 print/println 方法写数据，写的数据原样输出。 97->97
• 改变打印流向
  • 可以改变输出语句的目的地(打印流的流向)。
  • 输出语句，默认在控制台输出。
  • 使用 System.setOut 方法改变输出语句的目的地改为参数中传递的打印流的目的地。
    • static   void   setOut(PrintStream   out)
      • 重新分配“标准”输出流。

十一、File 类与 IO 完结