Java后端：IO流

File类

File类概述和构造方法

• File类介绍

  • 它是文件和目录路径名的抽象表示

  • 文件和目录是可以通过File封装成对象的

  • 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

• File类的构造方法

  方法名	说明
  File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
  File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的 File实例
  File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的 File实例

• 示例代码

  public class FileDemo01 {
      public static void main(String[] args) {
          //File(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
          File f1 = new File("E:\\itcast\\java.txt");
          System.out.println(f1);
  ​
          //File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的 File实例。
          File f2 = new File("E:\\itcast","java.txt");
          System.out.println(f2);
  ​
          //File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
          File f3 = new File("E:\\itcast");
          File f4 = new File(f3,"java.txt");
          System.out.println(f4);
      }
  }

File类创建功能

• 方法分类

  方法名	说明
  public boolean createNewFile()	当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
  public boolean mkdir()	创建由此抽象路径名命名的目录
  public boolean mkdirs()	创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

• 示例代码

  public class FileDemo02 {
      public static void main(String[] args) throws IOException {
          //需求1：我要在E:\\itcast目录下创建一个文件java.txt
          File f1 = new File("E:\\itcast\\java.txt");
          System.out.println(f1.createNewFile());
          System.out.println("--------");
  ​
          //需求2：我要在E:\\itcast目录下创建一个目录JavaSE
          File f2 = new File("E:\\itcast\\JavaSE");
          System.out.println(f2.mkdir());
          System.out.println("--------");
  ​
          //需求3：我要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
          File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
  //        System.out.println(f3.mkdir());
          System.out.println(f3.mkdirs());
          System.out.println("--------");
  ​
          //需求4：我要在E:\\itcast目录下创建一个文件javase.txt
          File f4 = new File("E:\\itcast\\javase.txt");
  //        System.out.println(f4.mkdir());
          System.out.println(f4.createNewFile());
      }
  }

File类判断和获取功能

• 判断功能

  方法名	说明
  public boolean isDirectory()	测试此抽象路径名表示的File是否为目录
  public boolean isFile()	测试此抽象路径名表示的File是否为文件
  public boolean exists()	测试此抽象路径名表示的File是否存在

• 获取功能

  方法名	说明
  public String getAbsolutePath()	返回此抽象路径名的绝对路径名字符串
  public String getPath()	将此抽象路径名转换为路径名字符串
  public String getName()	返回由此抽象路径名表示的文件或目录的名称
  public String[] list()	返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
  public File[] listFiles()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

• 示例代码

  public class FileDemo04 {
      public static void main(String[] args) {
          //创建一个File对象
          File f = new File("myFile\\java.txt");
  ​
  //        public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
  //        public boolean isFile()：测试此抽象路径名表示的File是否为文件
  //        public boolean exists()：测试此抽象路径名表示的File是否存在
          System.out.println(f.isDirectory());
          System.out.println(f.isFile());
          System.out.println(f.exists());
  ​
  //        public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
  //        public String getPath()：将此抽象路径名转换为路径名字符串
  //        public String getName()：返回由此抽象路径名表示的文件或目录的名称
          System.out.println(f.getAbsolutePath());
          System.out.println(f.getPath());
          System.out.println(f.getName());
          System.out.println("--------");
  ​
  //        public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
  //        public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组
          File f2 = new File("E:\\itcast");
  ​
          String[] strArray = f2.list();
          for(String str : strArray) {
              System.out.println(str);
          }
          System.out.println("--------");
  ​
          File[] fileArray = f2.listFiles();
          for(File file : fileArray) {
  //            System.out.println(file);
  //            System.out.println(file.getName());
              if(file.isFile()) {
                  System.out.println(file.getName());
              }
          }
      }
  }

File类删除功能

• 方法分类

  方法名	说明
  public boolean delete()	删除由此抽象路径名表示的文件或目录

• 示例代码

  public class FileDemo03 {
      public static void main(String[] args) throws IOException {
  //        File f1 = new File("E:\\itcast\\java.txt");
          //需求1：在当前模块目录下创建java.txt文件
          File f1 = new File("myFile\\java.txt");
  //        System.out.println(f1.createNewFile());
  ​
          //需求2：删除当前模块目录下的java.txt文件
          System.out.println(f1.delete());
          System.out.println("--------");
  ​
          //需求3：在当前模块目录下创建itcast目录
          File f2 = new File("myFile\\itcast");
  //        System.out.println(f2.mkdir());
  ​
          //需求4：删除当前模块目录下的itcast目录
          System.out.println(f2.delete());
          System.out.println("--------");
  ​
          //需求5：在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
          File f3 = new File("myFile\\itcast");
  //        System.out.println(f3.mkdir());
          File f4 = new File("myFile\\itcast\\java.txt");
  //        System.out.println(f4.createNewFile());
  ​
          //需求6：删除当前模块下的目录itcast
          System.out.println(f4.delete());
          System.out.println(f3.delete());
      }
  }

• 绝对路径和相对路径的区别

  • 绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：E:\itcast\java.txt

  • 相对路径：必须使用取自其他路径名的信息进行解释。例如：myFile\java.txt

递归

• 递归的介绍

  • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象

  • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解

  • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

• 递归的基本使用

  public class DiGuiDemo {
      public static void main(String[] args) {
          //回顾不死神兔问题，求第20个月兔子的对数
          //每个月的兔子对数：1,1,2,3,5,8，...
          int[] arr = new int[20];
  ​
          arr[0] = 1;
          arr[1] = 1;
  ​
          for (int i = 2; i < arr.length; i++) {
              arr[i] = arr[i - 1] + arr[i - 2];
          }
          System.out.println(arr[19]);
          System.out.println(f(20));
      }
  ​
      /*
          递归解决问题，首先就是要定义一个方法：
              定义一个方法f(n)：表示第n个月的兔子对数
              那么，第n-1个月的兔子对数该如何表示呢？f(n-1)
              同理，第n-2个月的兔子对数该如何表示呢？f(n-2)
  ​
          StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
       */
      public static int f(int n) {
          if(n==1 || n==2) {
              return 1;
          } else {
              return f(n - 1) + f(n - 2);
          }
      }
  }

• 递归的注意事项

  • 递归一定要有出口。否则内存溢出

  • 递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出

递归求阶乘

• 案例需求

  用递归求5的阶乘，并把结果在控制台输出

• 代码实现

  public class DiGuiDemo01 {
      public static void main(String[] args) {
          //调用方法
          int result = jc(5);
          //输出结果
          System.out.println("5的阶乘是：" + result);
      }
  ​
      //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
      public static int jc(int n) {
          //在方法内部判断该变量的值是否是1
          if(n == 1) {
              //是：返回1
              return 1;
          } else {
              //不是：返回n*(n-1)!
              return n*jc(n-1);
          }
      }
  }

  递归遍历目录

• 案例需求

  给定一个路径(E:\itcast)，通过递归完成遍历该目录下所有内容，并把所有文件的绝对路径输出在控制台

• 代码实现

public class DiGuiDemo02 {
    public static void main(String[] args) {
        //根据给定的路径创建一个File对象
//        File srcFile = new File("E:\\itcast");
        File srcFile = new File("E:\\itheima");

        //调用方法
        getAllFilePath(srcFile);
    }

    //定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
    public static void getAllFilePath(File srcFile) {
        //获取给定的File目录下所有的文件或者目录的File数组
        File[] fileArray = srcFile.listFiles();
        //遍历该File数组，得到每一个File对象
        if(fileArray != null) {
            for(File file : fileArray) {
                //判断该File对象是否是目录
                if(file.isDirectory()) {
                    //是：递归调用
                    getAllFilePath(file);
                } else {
                    //不是：获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

节点流（或文件流）
 

一、流的分类：

    1.操作数据单位：字节流、字符流
    2.数据的流向：输入流、输出流
    3.流的角色：节点流、处理流

 
二、流的体系结构

抽象基类：
InputStream    
OutputStream
Reader
Writer
    节点流（或文件流）
FileInputStream   (read(byte[] buffer))
FileOutputStream  (write(byte[] buffer,0,len)
FileReader (read(char[] cbuf))
FileWriter (write(char[] cbuf,0,len)
        缓冲流（处理流的一种）
BufferedInputStream (read(byte[] buffer))
BufferedOutputStream (write(byte[] buffer,0,len) / flush()
BufferedReader (read(char[] cbuf) / readLine())
BufferedWriter (write(char[] cbuf,0,len) / flush()

说明点：
    1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
    2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
    3. 读入的文件一定要存在，否则就会报FileNotFoundException。

缓冲流

    处理流之一：缓冲流的使用
 BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

    作用
   提供流的读取、写入的速度
   提高读写速度的原因：内部提供了一个缓冲区

   处理流，就是“套接”在已有的流的基础上

        处理步骤

• 造文件
• 造流
• 造节点流
• 造缓冲流
• 操作细节
• 关闭流，先关外再关内，而且关闭外层流的同时，内层流也会自动关闭，故可以省略内层流的关闭

转换流

    属于字符流
    InputStreamReader：将一个字节的输入流转换为字符的输入流
    OutputStreamWriter：将一个字符的输出流转换为字节的输出流

    作用：提供字节流与字符流之间的转换
     解码：字节、字节数组  --->字符数组、字符串
 编码：字符数组、字符串 ---> 字节、字节数组

    字符集

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

标准输入、输出流

    System类中有两个静态的成员变量
- public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
- public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
        输出语句的本质：是一个标准的输出流

- PrintStream ps = System.out;
- PrintStream类有的方法，System.out都可以使用

打印流

    打印流分类

- 字节打印流：PrintStream
- 字符打印流：PrintWriter
    打印流的特点

- 只负责输出数据，不负责读取数据
- 永远不会抛出IOException
- 有自己的特有方法
    字节打印流

-* PrintStream(String fileName)：使用指定的文件名创建新的打印流

- 使用继承父类的方法写数据，查看的时候会转码；使用自己的特有方法写数据，查看的数据原样输出

- 可以改变输出语句的目的地

  ​    public static void setOut(PrintStream out)：重新分配“标准”输出流

* PrintWriter(Writer   out, boolean autoFlush)：创建一个新的PrintWriter    out：字符输出流    autoFlush： 一个布尔值，如果为真，则println ， printf ，或format方法将刷新输出缓冲区

对象流

    对象序列化流

        对象序列化介绍

- 对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
- 这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
- 字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
- 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化
        - 对象序列化流： ObjectOutputStream

  - 将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象 
        常用方法

            构造方法
ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
            序列化对象的方法
void writeObject(Object obj)：将指定的对象写入ObjectOutputStream

    对象反序列化流

        - 对象反序列化流： ObjectInputStream

  - ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象
        常用方法

            构造方法
ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
            反序列化对象的方法
Object readObject()：从ObjectInputStream读取一个对象

8serialVersionUID&transient

    serialVersionUID

- 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
  - 会出问题，会抛出InvalidClassException异常
- 如果出问题了，如何解决呢？
  - 重新序列化
  - 给对象所属的类加一个serialVersionUID 
    - private static final long serialVersionUID = 42L;

    transient

- 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
  - 给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

Properties集合

    Properties介绍

- 是一个Map体系的集合类
- Properties可以保存到流中或从流中加载
- 属性列表中的每个键及其对应的值都是一个字符串
    Properties作为Map集合的特有方法

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

    和IO流结合的方法

void   load(InputStream inStream)：从输入字节流读取属性列表（键和元素对）
void   load(Reader reader)：从输入字符流读取属性列表（键和元素对）                       
void   store(OutputStream out, String comments) ：将此属性列表（键和元素对）写入此   Properties表中，以适合于使用   load(InputStream)方法的格式写入输出字节流 
void   store(Writer writer, String comments)：将此属性列表（键和元素对）写入此   Properties表中，以适合使用   load(Reader)方法的格式写入输出字符流