黑马程序员学习笔记——IO

IO

1.File类

1.1.File类概述和构造方法【应用】

• File类介绍

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

• File类的构造方法

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

• 示例代码

package com.lxy.File;

import java.io.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);
    }
}

1.2.File类创建功能【应用】

• 方法分类

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

• 示例代码

  package com.lxy.File;
  
  import java.io.File;
  import java.io.IOException;
  
  public class FileDemo02 {
      public static void main(String[] args) throws IOException {
          //需求1：
          File f1 = new File("操作文件\\java.txt");
          System.out.println(f1.createNewFile());
          System.out.println("--------");
  
          //需求2：
          File f2 = new File("操作文件\\JavaSE");
          System.out.println(f2.mkdir());
          System.out.println("--------");
  
          //需求3：
          File f3 = new File("操作文件\\JavaWEB\\HTML");
  //        System.out.println(f3.mkdir());
          System.out.println(f3.mkdirs());
          System.out.println("--------");
  
          //需求4：
          File f4 = new File("操作文件\\javase.txt");
  //        System.out.println(f4.mkdir());
          System.out.println(f4.createNewFile());
      }
  }
  

1.3.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对象数组

• 示例代码

package com.lxy.File;

import java.io.File;

public class FileDemo03 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("操作文件\\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("操作文件");

        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());
            }
        }
    }
}

1.4.File类删除功能【应用】

• 方法分类

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

• 示例代码

package com.lxy.File;

import java.io.File;
import java.io.IOException;

public class FileDemo04 {
    public static void main(String[] args) throws IOException {
        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("操作文件\\java.txt");
        System.out.println(f1.createNewFile());

        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在当前模块目录下创建javaSE目录
        File f2 = new File("操作文件\\javaSE");
        System.out.println(f2.mkdir());

        //需求4：删除当前模块目录下的javaSE目录
        System.out.println(f2.delete());
        System.out.println("--------");

        //需求5：在当前模块下创建一个目录javaSE,然后在该目录下创建一个文件java.txt
        File f3 = new File("操作文件\\javaSE");
        System.out.println(f3.mkdir());
        File f4 = new File("操作文件\\javaSE\\java.txt");
        System.out.println(f4.createNewFile());

        //需求6：删除当前模块下的目录javaSE
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

2.递归

2.1递归【应用】

• 递归的介绍

  • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
  • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
  • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

• 递归的基本使用

package com.lxy.digui;

public class DiguiDemo01 {
    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);
        }
    }
}

• 递归的注意事项

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

2.2.递归求阶乘【应用】

• 案例需求

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

• 代码实现

  package com.lxy.digui;
  
  public class DiguiDemo02 {
      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);
          }
      }
  }
  

2.3递归遍历目录【应用】

• 案例需求

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

• 代码实现

  package com.lxy.digui;
  
  import java.io.File;
  
  public class DiguiDekmo03 {
      public static void main(String[] args) {
          //根据给定的路径创建一个File对象
  //        File srcFile = new File("E:\\itcast");
          File srcFile = new File("操作文件");
  
          //调用方法
          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());
                  }
              }
          }
      }
  }
  

3.IO流

3.1 IO流概述和分类【理解】

• IO流介绍
  • IO：输入/输出(Input/Output)
  • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
  • IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载
• IO流的分类
  • 按照数据的流向
    • 输入流：读数据
    • 输出流：写数据
  • 按照数据类型来分
    • 字节流
      • 字节输入流
      • 字节输出流
    • 字符流
      • 字符输入流
      • 字符输出流
• IO流的使用场景
  • 如果操作的是纯文本文件，优先使用字符流
  • 如果操作的是图片、视频、音频等二进制文件。优先使用字节流
  • 如果不确定文件类型，优先使用字节流。字节流是万能的流

3.2字节流写数据【应用】

• 字节流抽象基类

  • InputStream：这个抽象类是表示字节输入流的所有类的超类
  • OutputStream：这个抽象类是表示字节输出流的所有类的超类
  • 子类名特点：子类名称都是以其父类名作为子类名的后缀

• 字节输出流

  • FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

• 使用字节输出流写数据的步骤

  • 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
  • 调用字节输出流对象的写数据方法
  • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

• 示例代码

  package com.lxy.IO;
  
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class FileOutputStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //创建字节输出流对象
          //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
          FileOutputStream fos = new FileOutputStream("操作文件\\fos.txt");
          /*
              做了三件事情：
                  A:调用系统功能创建了文件
                  B:创建了字节输出流对象
                  C:让字节输出流对象指向创建好的文件
           */
  
          //void write(int b)：将指定的字节写入此文件输出流
          fos.write(97);
  //        fos.write(57);
  //        fos.write(55);
  
          //最后都要释放资源
          //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
          fos.close();
      }
  }
  

3.3字节流写数据的三种方式【应用】

• 写数据的方法分类

  方法名	说明
  void write(int b)	将指定的字节写入此文件输出流 一次写一个字节数据
  void write(byte[] b)	将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
  void write(byte[] b, int off, int len)	将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据

• 示例代码

  package com.lxy.IO;
  
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class FileOutputStreamDemo02 {
      public static void main(String[] args) throws IOException {
          //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
          FileOutputStream fos = new FileOutputStream("操作文件\\fos.txt");
          //new File(name)
  //        FileOutputStream fos = new FileOutputStream(new File("操作文件\\fos.txt"));
  
          //FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件
  //        File file = new File("操作文件\\fos.txt");
  //        FileOutputStream fos2 = new FileOutputStream(file);
  //        FileOutputStream fos2 = new FileOutputStream(new File("操作文件\\fos.txt"));
  
          //void write(int b)：将指定的字节写入此文件输出流
  //        fos.write(97);
  //        fos.write(98);
  //        fos.write(99);
  //        fos.write(100);
  //        fos.write(101);
  
  //        void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
  //        byte[] bys = {97, 98, 99, 100, 101};
          //byte[] getBytes()：返回字符串对应的字节数组
          byte[] bys = "abcde".getBytes();
  //        fos.write(bys);
  
          //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
  //        fos.write(bys,0,bys.length);
          fos.write(bys,1,3);
  
          //释放资源
          fos.close();
      }
  }
  

3.4字节流写数据的两个小问题【应用】

• 字节流写数据如何实现换行

  • windows:\r\n
  • linux:\n
  • mac:\r

• 字节流写数据如何实现追加写入

  • public FileOutputStream(String name,boolean append)
  • 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

• 示例代码

  package com.lxy.IO;
  
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class FileOutputStreamDemo03 {
      public static void main(String[] args) throws IOException {
          //创建字节输出流对象
          //FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
          FileOutputStream fos = new FileOutputStream("操作文件\\os.txt",true);
  
          //写数据
          for (int i = 0; i < 10; i++) {
              fos.write("hello".getBytes());
              fos.write("\r\n".getBytes());
          }
  
          //释放资源
          fos.close();
      }
  }
  

3.5字节流写数据加异常处理【应用】

• 异常处理格式

  • try-catch-finally

    try{
    	可能出现异常的代码;
    }catch(异常类名 变量名){
    	异常的处理代码;
    }finally{
    	执行所有清除操作;
    }
    

  • finally特点

    • 被finally控制的语句一定会执行，除非JVM退出

• 示例代码

  package com.lxy.IO;
  
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class FileOutputStreamDemo04 {
      public static void main(String[] args) {
          //加入finally来实现释放资源
          FileOutputStream fos = null;
          try {
              fos = new FileOutputStream("操作文件\\fos.txt");
              fos.write("hello".getBytes());
          } catch (IOException e) {
              e.printStackTrace();
          } finally {
              if(fos != null) {
                  try {
                      fos.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
  }
  

3.6字节流读数据(一次读一个字节数据)【应用】

• 字节输入流

  • FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream ，该文件由文件系统中的路径名name命名

• 字节输入流读取数据的步骤

  • 创建字节输入流对象
  • 调用字节输入流对象的读数据方法
  • 释放资源

• 示例代码

  package com.lxy.IO;
  
  import java.io.FileInputStream;
  import java.io.IOException;
  
  public class FileInputStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //创建字节输入流对象
          //FileInputStream(String name)
          FileInputStream fis = new FileInputStream("操作文件\\fos.txt");
  
          int by;
          /*
              fis.read()：读数据
              by=fis.read()：把读取到的数据赋值给by
              by != -1：判断读取到的数据是否是-1
           */
          while ((by=fis.read())!=-1) {
              System.out.print((char)by);
          }
  
          //释放资源
          fis.close();
      }
  }
  

3.7字节流复制文本文件【应用】

• 案例需求

  ​ 把“E:\itcast\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”

• 实现步骤

  • 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)

  • 数据源：

    ​ E:\itcast\窗里窗外.txt — 读数据 — InputStream — FileInputStream

  • 目的地：

    ​ myByteStream\窗里窗外.txt — 写数据 — OutputStream — FileOutputStream

• 代码实现

  package com.lxy.IO;
  
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class CopytxtDemo01 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字节输入流对象
          FileInputStream fis = new FileInputStream("操作文件/中国石油大学北京.txt");
          //根据目的地创建字节输出流对象
          FileOutputStream fos = new FileOutputStream("操作文件/学校概况.txt");
  
          //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
          int by;
          while ((by=fis.read())!=-1) {
              fos.write(by);
          }
  
          //释放资源
          fos.close();
          fis.close();
      }
  }
  

3.8字节流读数据(一次读一个字节数组数据)【应用】

• 一次读一个字节数组的方法

  • public int read(byte[] b)：从输入流读取最多b.length个字节的数据
  • 返回的是读入缓冲区的总字节数,也就是实际的读取字节个数

• 示例代码

package com.lxy.IO;

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

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("操作文件\\fos.txt");

        /*
            hello\r\n
            world\r\n

            第一次：hello
            第二次：\r\nwor
            第三次：ld\r\nr

         */

        byte[] bys = new byte[1024]; //1024及其整数倍
        int len;
        while ((len = fis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }

        //释放资源
        fis.close();
    }
}

3.9字节流复制图片【应用】

• 案例需求

  ​ 把“E:\itcast\mn.jpg”复制到模块目录下的“mn.jpg”

• 实现步骤

  • 根据数据源创建字节输入流对象
  • 根据目的地创建字节输出流对象
  • 读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
  • 释放资源

• 代码实现

package com.lxy.IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyjpgDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\图片\\Saved Pictures\\1寸照片.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("操作文件\\1.jpg");

        //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }

        //释放资源
        fos.close();
        fis.close();
    }
}

4.字节缓冲流

4.1字节缓冲流构造方法【应用】

• 字节缓冲流介绍

  • BufferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

  • BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

• 构造方法：

  方法名	说明
  BufferedOutputStream(OutputStream out)	创建字节缓冲输出流对象
  BufferedInputStream(InputStream in)	创建字节缓冲输入流对象

• 示例代码

  package com.lxy.IO;
  
  import java.io.*;
  
  public class BufferStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //字节缓冲输出流：BufferedOutputStream(OutputStream out)
  
          BufferedOutputStream bos = new BufferedOutputStream
                  (new FileOutputStream("操作文件\\bos.txt"));
          //写数据
          bos.write("hello\r\n".getBytes());
          bos.write("world\r\n".getBytes());
          //释放资源
          bos.close();
  
  
          //字节缓冲输入流：BufferedInputStream(InputStream in)
          BufferedInputStream bis = new BufferedInputStream(
                  new FileInputStream("操作文件\\bos.txt"));
  
          //一次读取一个字节数据
  //        int by;
  //        while ((by=bis.read())!=-1) {
  //            System.out.print((char)by);
  //        }
  
          //一次读取一个字节数组数据
          byte[] bys = new byte[1024];
          int len;
          while ((len=bis.read(bys))!=-1) {
              System.out.print(new String(bys,0,len));
          }
  
          //释放资源
          bis.close();
      }
  }
  

4.2字节流复制视频【应用】

• 案例需求

  把“E:\itcast\字节流复制图片.avi”复制到模块目录下的“字节流复制图片.avi”

• 实现步骤

  • 根据数据源创建字节输入流对象

  • 根据目的地创建字节输出流对象

  • 读写数据，复制视频

  • 释放资源

• 代码实现

  package com.lxy.IO;
  
  import java.io.*;
  
  public class CopyMp4Demo01 {
      public static void main(String[] args) throws IOException {
          //记录开始时间
          long startTime = System.currentTimeMillis();
  
          //复制视频
  //        method1();
  //        method2();
  //        method3();
          method4();
  
          //记录结束时间
          long endTime = System.currentTimeMillis();
          System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
      }
  
      //字节缓冲流一次读写一个字节数组
      public static void method4() throws IOException {
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\视频\\2022级经管院迎新晚会\\1.mp4"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("操作文件\\1.mp4"));
  
          byte[] bys = new byte[1024];
          int len;
          while ((len=bis.read(bys))!=-1) {
              bos.write(bys,0,len);
          }
  
          bos.close();
          bis.close();
      }
  
      //字节缓冲流一次读写一个字节
      public static void method3() throws IOException {
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\视频\\2022级经管院迎新晚会\\1.mp4"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("操作文件\\1.mp4"));
  
          int by;
          while ((by=bis.read())!=-1) {
              bos.write(by);
          }
  
          bos.close();
          bis.close();
      }
  
  
      //基本字节流一次读写一个字节数组
      public static void method2() throws IOException {
          FileInputStream fis = new FileInputStream("E:\\视频\\2022级经管院迎新晚会\\1.mp4");
          FileOutputStream fos = new FileOutputStream("操作文件\\1.mp4");
  
          byte[] bys = new byte[1024];
          int len;
          while ((len=fis.read(bys))!=-1) {
              fos.write(bys,0,len);
          }
  
          fos.close();
          fis.close();
      }
  
      //基本字节流一次读写一个字节
      public static void method1() throws IOException {
          FileInputStream fis = new FileInputStream("E:\\视频\\2022级经管院迎新晚会\\1.mp4");
          FileOutputStream fos = new FileOutputStream("操作文件\\1.mp4");
  
          int by;
          while ((by=fis.read())!=-1) {
              fos.write(by);
          }
  
          fos.close();
          fis.close();
      }
  }
  

5.字符流

5.1为什么会出现字符流【理解】

• 字符流的介绍

  由于字节流操作中文不是特别的方便，所以Java就提供字符流

  字符流 = 字节流 + 编码表

• 中文的字节存储方式

  用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

  汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

5.2编码表【理解】

• 什么是字符集

  是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

  计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

• 常见的字符集

  • ASCII字符集：

    ASCII：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)

    基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

  • GBXXX字符集：

    GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

  • Unicode字符集：

    UTF-8编码：可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用 中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码

    编码规则：

    • 128个US-ASCII字符，只需一个字节编码
    • 拉丁文等字符，需要二个字节编码
    • 大部分常用字（含中文），使用三个字节编码
    • 其他极少使用的Unicode辅助字符，使用四字节编码

5.3字符串中的编码解码问题【应用】

• 相关方法

  方法名	说明
  byte[] getBytes()	使用平台的默认字符集将该 String编码为一系列字节
  byte[] getBytes(String charsetName)	使用指定的字符集将该 String编码为一系列字节
  String(byte[] bytes)	使用平台的默认字符集解码指定的字节数组来创建字符串
  String(byte[] bytes, String charsetName)	通过指定的字符集解码指定的字节数组来创建字符串

package com.lxy.IO;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo01 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";

        //byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
        //byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
        byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        //String ss = new String(bys);
        //String ss = new String(bys,"UTF-8");
        String ss = new String(bys,"GBK");
        System.out.println(ss);
    }
}

5.4字符流中的编码解码问题【应用】

• 字符流中和编码解码问题相关的两个类

  • InputStreamReader：是从字节流到字符流的桥梁

    ​ 它读取字节，并使用指定的编码将其解码为字符

    ​ 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

  • OutputStreamWriter：是从字符流到字节流的桥梁

    ​ 是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节

    ​ 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

• 构造方法

• 方法名	说明
  InputStreamReader(InputStream in)	使用默认字符编码创建InputStreamReader对象
  InputStreamReader(InputStream in,String chatset)	使用指定的字符编码创建InputStreamReader对象
  OutputStreamWriter(OutputStream out)	使用默认字符编码创建OutputStreamWriter对象
  OutputStreamWriter(OutputStream out,String charset)	使用指定的字符编码创建OutputStreamWriter对象

• 代码演示

  package com.lxy.IO;
  
  import java.io.*;
  
  public class ConversionStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
          OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("操作文件\\osw.txt"),"GBK");
          osw.write("中国");
          osw.close();
  
          //InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
          InputStreamReader isr = new InputStreamReader(new FileInputStream("操作文件\\osw.txt"),"GBK");
          //一次读取一个字符数据
          int ch;
          while ((ch=isr.read())!=-1) {
              System.out.print((char)ch);
          }
          isr.close();
      }
  }
  

5.5字符流写数据的5种方式【应用】

• 方法介绍

  方法名	说明
  void write(int c)	写一个字符
  void write(char[] cbuf)	写入一个字符数组
  void write(char[] cbuf, int off, int len)	写入字符数组的一部分
  void write(String str)	写一个字符串
  void write(String str, int off, int len)	写一个字符串的一部分

• 刷新和关闭的方法

  方法名	说明
  flush()	刷新流，之后还可以继续写数据
  close()	关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

• 代码演示

  package com.lxy.IO;
  
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  
  public class OutputStreamWriterDemo01 {
      public static void main(String[] args) throws IOException {
          OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("操作文件\\osw.txt"));
  
          //void write(int c)：写一个字符
          osw.write(97);
          osw.write(98);
          osw.write(99);
  
          //void writ(char[] cbuf)：写入一个字符数组
  //        char[] chs = {'a', 'b', 'c', 'd', 'e'};
  //        osw.write(chs);
  
          //void write(char[] cbuf, int off, int len)：写入字符数组的一部分
  //        osw.write(chs, 0, chs.length);
  //        osw.write(chs, 1, 3);
  
          //void write(String str)：写一个字符串
  //        osw.write("abcde");
  
          //void write(String str, int off, int len)：写一个字符串的一部分
  //        osw.write("abcde", 0, "abcde".length());
  //        osw.write("abcde", 1, 3);
  
          //释放资源
          osw.close();
      }
  }
  

5.6字符流读数据的2种方式【应用】

• 方法介绍

  方法名	说明
  int read()	一次读一个字符数据
  int read(char[] cbuf)	一次读一个字符数组数据

• 代码演示

  package com.lxy.IO;
  
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStreamReader;
  
  public class InputStreamReaderDemo01 {
      public static void main(String[] args) throws IOException {
  
          InputStreamReader isr = new InputStreamReader(new FileInputStream("操作文件\\ConversionStreamDemo01.java"));
  
          //int read()：一次读一个字符数据
  //        int ch;
  //        while ((ch=isr.read())!=-1) {
  //            System.out.print((char)ch);
  //        }
  
          //int read(char[] cbuf)：一次读一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len = isr.read(chs)) != -1) {
              System.out.print(new String(chs, 0, len));
          }
  
          //释放资源
          isr.close();
      }
  }
  

5.7字符流复制Java文件【应用】

• 案例需求

  把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”

• 实现步骤

  • 根据数据源创建字符输入流对象
  • 根据目的地创建字符输出流对象
  • 读写数据，复制文件
  • 释放资源

• 代码实现

  package com.lxy.IO;
  
  import java.io.*;
  
  public class CopyJavaDemo01 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符输入流对象
          InputStreamReader isr = new InputStreamReader(new FileInputStream("操作文件\\ConversionStreamDemo01.java"));
          //根据目的地创建字符输出流对象
          OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("操作文件\\Copy.java"));
  
          //读写数据，复制文件
          //一次读写一个字符数据
  //        int ch;
  //        while ((ch=isr.read())!=-1) {
  //            osw.write(ch);
  //        }
  
          //一次读写一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len=isr.read(chs))!=-1) {
              osw.write(chs,0,len);
          }
  
          //释放资源
          osw.close();
          isr.close();
      }
  }
  

5.8字符流复制Java文件改进版【应用】

• 案例需求

  使用便捷流对象，把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”

• 实现步骤

  • 根据数据源创建字符输入流对象

  • 根据目的地创建字符输出流对象

  • 读写数据，复制文件

  • 释放资源

• 代码实现

  package com.lxy.IO;
  
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  
  public class CopyJavaDemo02 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符输入流对象
          FileReader fr = new FileReader("操作文件\\ConversionStreamDemo01.java");
          //根据目的地创建字符输出流对象
          FileWriter fw = new FileWriter("操作文件\\Copy.java");
          //读写数据，复制文件
  //        int ch;
  //        while ((ch=fr.read())!=-1) {
  //            fw.write(ch);
  //        }
  
          char[] chs = new char[1024];
          int len;
          while ((len = fr.read(chs)) != -1) {
              fw.write(chs, 0, len);
          }
  
          //释放资源
          fw.close();
          fr.close();
      }
  }
  

5.9字符缓冲流【应用】

• 字符缓冲流介绍

  • BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

  • BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

• 构造方法

  方法名	说明
  BufferedWriter(Writer out)	创建字符缓冲输出流对象
  BufferedReader(Reader in)	创建字符缓冲输入流对象

• 代码演示

  package com.lxy.IO;
  
  import java.io.*;
  
  public class BufferedStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //BufferedWriter(Writer out)
          BufferedWriter bw = new BufferedWriter(new FileWriter("操作文件\\bw.txt"));
          bw.write("hello\r\n");
          bw.write("world\r\n");
          bw.close();
  
          //BufferedReader(Reader in)
          BufferedReader br = new BufferedReader(new FileReader("操作文件\\bw.txt"));
  
          //一次读取一个字符数据
  //        int ch;
  //        while ((ch=br.read())!=-1) {
  //            System.out.print((char)ch);
  //        }
  
          //一次读取一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len = br.read(chs)) != -1) {
              System.out.print(new String(chs, 0, len));
          }
  
          br.close();
      }
  }
  

5.10字符缓冲流复制Java文件【应用】

• 案例需求

  把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java

• 实现步骤

  • 根据数据源创建字符缓冲输入流对象
  • 根据目的地创建字符缓冲输出流对象
  • 读写数据，复制文件，使用字符缓冲流特有功能实现
  • 释放资源

• 代码实现

  package com.lxy.IO;
  
  import java.io.*;
  
  public class CopyJavaDemo03 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符缓冲输入流对象
          BufferedReader br = new BufferedReader(new FileReader("操作文件\\ConversionStreamDemo01.java"));
          //根据目的地创建字符缓冲输出流对象
          BufferedWriter bw = new BufferedWriter(new FileWriter("操作文件\\Copy.java"));
  
          //读写数据，复制文件
          //一次读写一个字符数据
  //        int ch;
  //        while ((ch=br.read())!=-1) {
  //            bw.write(ch);
  //        }
  
          //一次读写一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len=br.read(chs))!=-1) {
              bw.write(chs,0,len);
          }
  
          //释放资源
          bw.close();
          br.close();
      }
  }
  

5.11字符缓冲流特有功能【应用】

• 方法介绍

  BufferedWriter：

  方法名	说明
  void newLine()	写一行行分隔符，行分隔符字符串由系统属性定义

  BufferedReader:

  方法名	说明
  String readLine()	读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

• 代码演示

  package com.lxy.IO;
  
  import java.io.*;
  
  public class BufferedStreamDemo02 {
      public static void main(String[] args) throws IOException {
  
          //创建字符缓冲输出流
          BufferedWriter bw = new BufferedWriter(new FileWriter("操作文件\\bw.txt"));
  
          //写数据
          for (int i = 0; i < 10; i++) {
              bw.write("hello" + i);
              //bw.write("\r\n");
              bw.newLine();
              bw.flush();
          }
  
          //释放资源
          bw.close();
  
          //创建字符缓冲输入流
          BufferedReader br = new BufferedReader(new FileReader("操作文件\\bw.txt"));
  
          String line;
          while ((line = br.readLine()) != null) {
              System.out.println(line);
          }
  
          br.close();
      }
  }
  

5.12字符缓冲流特有功能复制Java文件【应用】

• 案例需求

  使用特有功能把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java

• 实现步骤

  • 根据数据源创建字符缓冲输入流对象
  • 根据目的地创建字符缓冲输出流对象
  • 读写数据，复制文件，使用字符缓冲流特有功能实现
  • 释放资源

• 代码实现

  package com.lxy.IO;
  
  import java.io.*;
  
  public class CopyJavaDemo04 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符缓冲输入流对象
          BufferedReader br = new BufferedReader(new FileReader("操作文件\\ConversionStreamDemo01.java"));
          //根据目的地创建字符缓冲输出流对象
          BufferedWriter bw = new BufferedWriter(new FileWriter("操作文件\\Copy.java"));
  
          //读写数据，复制文件
          //使用字符缓冲流特有功能实现
          String line;
          while ((line=br.readLine())!=null) {
              bw.write(line);
              bw.newLine();
              bw.flush();
          }
  
          //释放资源
          bw.close();
          br.close();
      }
  }
  

5.13IO流小结【理解】

6.练习案例

6.1文件到集合【应用】

• 案例需求

  把ArrayList集合中的字符串数据写入到文本文件。要求：每一个字符串元素作为文件中的一行数据

• 实现步骤

  • 创建ArrayList集合
  • 往集合中存储字符串元素
  • 创建字符缓冲输出流对象
  • 遍历集合，得到每一个字符串数据
  • 调用字符缓冲输出流对象的方法写数据
  • 释放资源

• 代码实现

  package com.lxy.IO;
  
  import java.io.BufferedWriter;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.util.ArrayList;
  
  public class ArrayListToTxtDemo01 {
      public static void main(String[] args) throws IOException {
          //创建ArrayList集合
          ArrayList<String> array = new ArrayList<String>();
  
          //往集合中存储字符串元素
          array.add("hello");
          array.add("world");
          array.add("java");
  
          //创建字符缓冲输出流对象
          BufferedWriter bw = new BufferedWriter(new FileWriter("操作文件\\array.txt"));
  
          //遍历集合，得到每一个字符串数据
          for (String s : array) {
              //调用字符缓冲输出流对象的方法写数据
              bw.write(s);
              bw.newLine();
              bw.flush();
          }
  
          //释放资源
          bw.close();
      }
  }
  

6.2集合到文件【应用】

• 案例需求

  把文本文件中的数据读取到集合中，并遍历集合。要求：文件中每一行数据是一个集合元素

• 实现步骤

  • 创建字符缓冲输入流对象
  • 创建ArrayList集合对象
  • 调用字符缓冲输入流对象的方法读数据
  • 把读取到的字符串数据存储到集合中
  • 释放资源
  • 遍历集合

• 代码实现

  package com.lxy.IO;
  
  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  import java.util.ArrayList;
  
  public class TxtToArrayListDemo01 {
      public static void main(String[] args) throws IOException {
          //创建字符缓冲输入流对象
          BufferedReader br = new BufferedReader(new FileReader("操作文件\\array.txt"));
  
          //创建ArrayList集合对象
          ArrayList<String> array = new ArrayList<String>();
  
          //调用字符缓冲输入流对象的方法读数据
          String line;
          while ((line = br.readLine()) != null) {
              //把读取到的字符串数据存储到集合中
              array.add(line);
          }
          //释放资源
          br.close();
          //遍历集合
          for (String s : array) {
              System.out.println(s);
          }
      }
  }
  

6.3点名器【应用】

• 案例需求

  我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随点名器

• 实现步骤

  • 创建字符缓冲输入流对象
  • 创建ArrayList集合对象
  • 调用字符缓冲输入流对象的方法读数据
  • 把读取到的字符串数据存储到集合中
  • 释放资源
  • 使用Random产生一个随机数，随机数的范围在：[0,集合的长度)
  • 把第6步产生的随机数作为索引到ArrayList集合中获取值
  • 把第7步得到的数据输出在控制台

• 代码实现

  package com.lxy.IO;
  
  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Random;
  
  public class CallNameDemo01 {
      public static void main(String[] args) throws IOException {
          //创建字符缓冲输入流对象
          BufferedReader br = new BufferedReader(new FileReader("操作文件\\names.txt"));
  
          //创建ArrayList集合对象
          ArrayList<String> array = new ArrayList<String>();
  
          //调用字符缓冲输入流对象的方法读数据
          String line;
          while ((line=br.readLine())!=null) {
              //把读取到的字符串数据存储到集合中
              array.add(line);
          }
  
          //释放资源
          br.close();
  
          //使用Random产生一个随机数，随机数的范围在：[0,集合的长度)
          Random r = new Random();
          int index = r.nextInt(array.size());
  
          //把第6步产生的随机数作为索引到ArrayList集合中获取值
          String name = array.get(index);
  
          //把第7步得到的数据输出在控制台
          System.out.println("幸运者是：" + name);
      }
  }
  

6.4集合到文件改进版【应用】

• 案例需求

  把ArrayList集合中的学生数据写入到文本文件。要求：每一个学生对象的数据作为文件中的一行数据
  ​ 格式：学号,姓名,年龄,居住地 举例：itheima001,林青霞,30,西安

• 实现步骤

  • 定义学生类
  • 创建ArrayList集合
  • 创建学生对象
  • 把学生对象添加到集合中
  • 创建字符缓冲输出流对象
  • 遍历集合，得到每一个学生对象
  • 把学生对象的数据拼接成指定格式的字符串
  • 调用字符缓冲输出流对象的方法写数据
  • 释放资源

• 代码实现

  • 学生类

    package com.lxy.IO;
    
    public class Student {
        private String sid;
        private String name;
        private int age;
        private String address;
    
        public Student() {
        }
    
        public Student(String sid, String name, int age, String address) {
            this.sid = sid;
            this.name = name;
            this.age = age;
            this.address = address;
        }
    
        public String getSid() {
            return sid;
        }
    
        public void setSid(String sid) {
            this.sid = sid;
        }
    
        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;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    }
    

  • 测试类

    package com.lxy.IO;
    
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.ArrayList;
    
    public class ArrayListToFileDemo01 {
        public static void main(String[] args) throws IOException {
            //创建ArrayList集合
            ArrayList<Student> array = new ArrayList<Student>();
    
            //创建学生对象
            Student s1 = new Student("itheima001", "林青霞", 30, "西安");
            Student s2 = new Student("itheima002", "张曼玉", 35, "武汉");
            Student s3 = new Student("itheima003", "王祖贤", 33, "郑州");
            //把学生对象添加到集合中
            array.add(s1);
            array.add(s2);
            array.add(s3);
    
            //创建字符缓冲输出流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("操作文件\\students.txt"));
    
            //遍历集合，得到每一个学生对象
            for (Student s : array) {
                //把学生对象的数据拼接成指定格式的字符串
                StringBuilder sb = new StringBuilder();
                sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());
    
                //调用字符缓冲输出流对象的方法写数据
                bw.write(sb.toString());
                bw.newLine();
                bw.flush();
            }
    
            //释放资源
            bw.close();
        }
    }
    

6.5文件到集合改进版【应用】

• 案例需求

  把文本文件中的数据读取到集合中，并遍历集合。要求：文件中每一行数据是一个学生对象的成员变量值

  举例：itheima001,林青霞,30,西安

• 实现步骤

  • 定义学生类
  • 创建字符缓冲输入流对象
  • 创建ArrayList集合对象
  • 调用字符缓冲输入流对象的方法读数据
  • 把读取到的字符串数据用split()进行分割，得到一个字符串数组
  • 创建学生对象
  • 把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
  • 把学生对象添加到集合
  • 释放资源
  • 遍历集合

• 代码实现

  • 学生类

    package com.lxy.IO;
    
    public class Student {
        private String sid;
        private String name;
        private int age;
        private String address;
    
        public Student() {
        }
    
        public Student(String sid, String name, int age, String address) {
            this.sid = sid;
            this.name = name;
            this.age = age;
            this.address = address;
        }
    
        public String getSid() {
            return sid;
        }
    
        public void setSid(String sid) {
            this.sid = sid;
        }
    
        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;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    }
    

  • 测试类

    package com.lxy.IO;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.ArrayList;
    
    public class FileToArrayListDemo01 {
        public static void main(String[] args) throws IOException {
            //创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("操作文件\\students.txt"));
    
            //创建ArrayList集合对象
            ArrayList<Student> array = new ArrayList<Student>();
    
            //调用字符缓冲输入流对象的方法读数据
            String line;
            while ((line = br.readLine()) != null) {
                //把读取到的字符串数据用split()进行分割，得到一个字符串数组
                String[] strArray = line.split(",");
    
                //创建学生对象
                Student s = new Student();
                //把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
                //itheima001,林青霞,30,西安
                s.setSid(strArray[0]);
                s.setName(strArray[1]);
                s.setAge(Integer.parseInt(strArray[2]));
                s.setAddress(strArray[3]);
    
                //把学生对象添加到集合
                array.add(s);
            }
    
            //释放资源
            br.close();
    
            //遍历集合
            for (Student s : array) {
                System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge() + "," + s.getAddress());
            }
        }
    }
    

6.6集合到文件数据排序改进版【应用】

6.6.1案例需求

• 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件
• 格式：姓名,语文成绩,数学成绩,英语成绩 举例：林青霞,98,99,100

6.6.2分析步骤

1. 定义学生类
2. 创建TreeSet集合，通过比较器排序进行排序
3. 键盘录入学生数据
4. 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
5. 把学生对象添加到TreeSet集合
6. 创建字符缓冲输出流对象
7. 遍历集合，得到每一个学生对象
8. 把学生对象的数据拼接成指定格式的字符串
9. 调用字符缓冲输出流对象的方法写数据
10. 释放资源

6.6.3代码实现

• 学生类

  package com.lxy.IO;
  
  public class Student2 {
      // 姓名
      private String name;
      // 语文成绩
      private int chinese;
      // 数学成绩
      private int math;
      // 英语成绩
      private int english;
  
      public Student2() {
         
      }
  
      public Student2(String name, int chinese, int math, int english) {
          super();
          this.name = name;
          this.chinese = chinese;
          this.math = math;
          this.english = english;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public int getChinese() {
          return chinese;
      }
  
      public void setChinese(int chinese) {
          this.chinese = chinese;
      }
  
      public int getMath() {
          return math;
      }
  
      public void setMath(int math) {
          this.math = math;
      }
  
      public int getEnglish() {
          return english;
      }
  
      public void setEnglish(int english) {
          this.english = english;
      }
  
      public int getSum() {
          return this.chinese + this.math + this.english;
      }
  }
  

• 测试类

  package com.lxy.IO;
  
  import java.io.BufferedWriter;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.util.Comparator;
  import java.util.Scanner;
  import java.util.TreeSet;
  
  public class TreeSetToFileDemo01 {
      public static void main(String[] args) throws IOException {
          //创建TreeSet集合，通过比较器排序进行排序
          TreeSet<Student2> ts = new TreeSet<Student2>(new Comparator<Student2>() {
              @Override
              public int compare(Student2 s1, Student2 s2) {
                  //成绩总分从低到高
                  int num = s1.getSum() - s2.getSum();
                  //次要条件
                  int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                  int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                  int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;
                  return num4;
              }
          });
  
          //键盘录入学生数据
          for (int i = 0; i < 5; i++) {
              Scanner sc = new Scanner(System.in);
              System.out.println("请录入第" + (i + 1) + "个学生信息：");
              System.out.println("姓名：");
              String name = sc.nextLine();
              System.out.println("语文成绩：");
              int chinese = sc.nextInt();
              System.out.println("数学成绩：");
              int math = sc.nextInt();
              System.out.println("英语成绩：");
              int english = sc.nextInt();
  
              //创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
              Student2 s = new Student2();
              s.setName(name);
              s.setChinese(chinese);
              s.setMath(math);
              s.setEnglish(english);
  
              //把学生对象添加到TreeSet集合
              ts.add(s);
          }
  
          //创建字符缓冲输出流对象
          BufferedWriter bw = new BufferedWriter(new FileWriter("操作文件\\ts.txt"));
  
          //遍历集合，得到每一个学生对象
          for (Student2 s : ts) {
              //把学生对象的数据拼接成指定格式的字符串
              //格式：姓名,语文成绩,数学成绩,英语成绩
              StringBuilder sb = new StringBuilder();
              sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());
  
  //            调用字符缓冲输出流对象的方法写数据
              bw.write(sb.toString());
              bw.newLine();
              bw.flush();
          }
  
          //释放资源
          bw.close();
      }
  }
  

6.7.复制单级文件夹【应用】

6.7.1案例需求

• 把“E:\itcast”这个文件夹复制到模块目录下

6.7.2分析步骤

1. 创建数据源目录File对象，路径是E:\itcast

2. 获取数据源目录File对象的名称

3. 创建目的地目录File对象，路径由(模块名+第2步获取的名称)组成

4. 判断第3步创建的File是否存在，如果不存在，就创建

5. 获取数据源目录下所有文件的File数组

6. 遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件

7. 获取数据源文件File对象的名称

8. 创建目的地文件File对象，路径由(目的地目录+第7步获取的名称)组成

9. 复制文件

   ​ 由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件

   ​ 采用参数为File的构造方法

6.7.3代码实现

package com.lxy.IO;

import java.io.*;

public class CopyFolderDemo01 {
    public static void main(String[] args) throws IOException {
        //创建数据源目录File对象，路径是E:\\音乐
        File srcFolder = new File("E:\\音乐");

        //获取数据源目录File对象的名称 音乐
        String srcFolderName = srcFolder.getName();

        //创建目的地目录File对象，路径名是音乐
        File destFolder = new File(srcFolderName);

        //判断目的地目录对应的File是否存在，如果不存在，就创建
        if(!destFolder.exists()) {
            destFolder.mkdir();
        }

        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();

        //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for(File srcFile : listFiles) {
            //数据源文件：
            //获取数据源文件File对象的名称
            String srcFileName = srcFile.getName();
            //创建目的地文件File对象，路径名是目的地目录+mn.jpg组成(音乐\\1.mp3)
            File destFile = new File(destFolder,srcFileName);
            //复制文件
            copyFile(srcFile,destFile);
        }
    }

    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }
}

6.8复制多级文件夹【应用】

6.8.1案例需求

• 把“E:\itcast”这个文件夹复制到 F盘目录下

6.8.2分析步骤

1. 创建数据源File对象，路径是E:\itcast

2. 创建目的地File对象，路径是F:\

3. 写方法实现文件夹的复制，参数为数据源File对象和目的地File对象

4. 判断数据源File是否是文件

   ​ 是文件：直接复制，用字节流

   ​ 不是文件：在目的地下创建该目录

   ​ 遍历获取该目录下的所有文件的File数组，得到每一个File对象

   ​ 回到3继续(递归)

6.8.3代码实现

package com.lxy.IO;

import java.io.*;

public class CopyFoldersDemo01 {
    public static void main(String[] args) throws IOException {
        //创建数据源File对象，路径是E:\\itcast
        File srcFile = new File("F:\\计算机二级");
        //创建目的地File对象，路径是F:\\
        File destFile = new File("");
        File absolutedestFile = destFile.getAbsoluteFile();

        //写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
        copyFolder(srcFile,absolutedestFile);
    }

    //复制文件夹
    private static void copyFolder(File srcFile, File destFile) throws IOException {
        //判断数据源File是否是目录
        if(srcFile.isDirectory()) {
            //在目的地下创建和数据源File名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile,srcFileName);
            if(!newFolder.exists()) {
                newFolder.mkdir();
            }

            //获取数据源File下所有文件或者目录的File数组
            File[] fileArray = srcFile.listFiles();

            //遍历该File数组，得到每一个File对象
            for(File file : fileArray) {
                //把该File作为数据源File对象，递归调用复制文件夹的方法
                copyFolder(file,newFolder);
            }
        } else {
            //说明是文件，直接复制，用字节流
            File newFile = new File(destFile,srcFile.getName());
            copyFile(srcFile,newFile);
        }
    }

    //字节缓冲流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }
}

6.9复制文件的异常处理【应用】

6.9.1基本做法

package com.lxy.IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFileDemo01 {
    public static void main(String[] args) {
        method2();
    }

    //try...catch...finally
    private static void method2() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("操作文件\\fr.txt");
            fw = new FileWriter("操作文件\\fw.txt");

            char[] chs = new char[1024];
            int len;
            while ((len = fr.read(chs)) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fw!=null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fr!=null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //抛出处理
    private static void method1() throws IOException {
        FileReader fr = new FileReader("操作文件\\fr.txt");
        FileWriter fw = new FileWriter("操作文件\\fw.txt");

        char[] chs = new char[1024];
        int len;
        while ((len = fr.read(chs) != -1) {
            fw.write(chs, 0, len);
        }

        fw.close();
        fr.close();
    }
}

6.9.2.JDK7版本改进

package com.lxy.IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFileDemo02 {
    public static void main(String[] args) {
        method3();
    }


    //JDK7的改进方案
    private static void method3() {
        try(FileReader fr = new FileReader("操作文件\\fr.txt");
            FileWriter fw = new FileWriter("操作文件\\fw.txt")) {
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read(chs)) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6.9.3JDK9版本改进

package com.lxy.IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFileDemo03 {
    public static void main(String[] args) {

    }

    //JDK9的改进方案
    private static void method4() throws IOException {
        FileReader fr = new FileReader("操作文件\\fr.txt");
        FileWriter fw = new FileWriter("操作文件\\fw.txt");
        try(fr;fw){
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7.IO特殊操作流

7.1标准输入流【应用】

• System类中有两个静态的成员变量

  • public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
  • public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

• 自己实现键盘录入数据

  package com.lxy.IO;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Scanner;
  
  public class SystemInDemo01 {
      public static void main(String[] args) throws IOException {
          //public static final InputStream in：标准输入流
  //        InputStream is = System.in;
  
  //        int by;
  //        while ((by=is.read())!=-1) {
  //            System.out.print((char)by);
  //        }
  
          //如何把字节流转换为字符流？用转换流
  //        InputStreamReader isr = new InputStreamReader(is);
  //        //使用字符流能不能够实现一次读取一行数据呢？可以
  //        //但是，一次读取一行数据的方法是字符缓冲输入流的特有方法
  //        BufferedReader br = new BufferedReader(isr);
  
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
          System.out.println("请输入一个字符串：");
          String line = br.readLine();
          System.out.println("你输入的字符串是：" + line);
  
          System.out.println("请输入一个整数：");
          int i = Integer.parseInt(br.readLine());
          System.out.println("你输入的整数是：" + i);
  
          //自己实现键盘录入数据太麻烦了，所以Java就提供了一个类供我们使用
          Scanner sc = new Scanner(System.in);
      }
  }
  

7.2标准输出流【应用】

• System类中有两个静态的成员变量

  • public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
  • public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

• 输出语句的本质：是一个标准的输出流

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

• 示例代码

  package com.lxy.IO;
  
  import java.io.PrintStream;
  
  public class SystemOutDemo01 {
      public static void main(String[] args) {
          //public static final PrintStream out：标准输出流
          PrintStream ps = System.out;
  
          //能够方便地打印各种数据值
  //        ps.print("hello");
  //        ps.print(100);
  
  //        ps.println("hello");
  //        ps.println(100);
  
          //System.out的本质是一个字节输出流
          System.out.println("hello");
          System.out.println(100);
  
          System.out.println();
  //        System.out.print();
      }
  }
  

7.3字节打印流【应用】

• 打印流分类

  • 字节打印流：PrintStream
  • 字符打印流：PrintWriter

• 打印流的特点

  • 只负责输出数据，不负责读取数据
  • 永远不会抛出IOException
  • 有自己的特有方法

• 字节打印流

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

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

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

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

• 示例代码

  package com.lxy.IO;
  
  import java.io.IOException;
  import java.io.PrintStream;
  
  public class PrintStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //PrintStream(String fileName)：使用指定的文件名创建新的打印流
          PrintStream ps = new PrintStream("操作文件\\ps.txt");
  
          //写数据
          //字节输出流有的方法
  //        ps.write(97);
  
          //使用特有方法写数据
  //        ps.print(97);
  //        ps.println();
  //        ps.print(98);
          ps.println(97);
          ps.println(98);
  
          //释放资源
          ps.close();
      }
  }
  

7.4字符打印流【应用】

• 字符打印流构造方法

  方法名	说明
  PrintWriter(String fileName)	使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新
  PrintWriter(Writer out, boolean autoFlush)	创建一个新的PrintWriter out：字符输出流 autoFlush： 一个布尔值，如果为真，则println ， printf ，或format方法将刷新输出缓冲区

• 示例代码

  package com.lxy.IO;
  
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.PrintWriter;
  
  public class PrintWriterDemo01 {
      public static void main(String[] args) throws IOException {
          //PrintWriter(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新
  //        PrintWriter pw = new PrintWriter("myOtherStream\\pw.txt");
  
  //        pw.write("hello");
  //        pw.write("\r\n");
  //        pw.flush();
  //        pw.write("world");
  //        pw.write("\r\n");
  //        pw.flush();
  
  //        pw.println("hello");
          /*
              pw.write("hello");
              pw.write("\r\n");
           */
  //        pw.flush();
  //        pw.println("world");
  //        pw.flush();
  
          //PrintWriter(Writer out, boolean autoFlush)：创建一个新的PrintWriter
          PrintWriter pw = new PrintWriter(new FileWriter("操作文件\\pw.txt"), true);
  //        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\pw.txt"),false);
  
          pw.println("hello");
          /*
              pw.write("hello");
              pw.write("\r\n");
              pw.flush();
           */
          pw.println("world");
  
          pw.close();
      }
  }
  

7.5复制Java文件打印流改进版【应用】

• 案例需求

  • 把模块目录下的PrintStreamDemo.java 复制到模块目录下的 Copy.java

• 分析步骤

  • 根据数据源创建字符输入流对象
  • 根据目的地创建字符输出流对象
  • 读写数据，复制文件
  • 释放资源

• 代码实现

  package com.lxy.IO;
  
  import java.io.*;
  
  public class CopyJavaDemo06 {
      public static void main(String[] args) throws IOException {
          /*
          //根据数据源创建字符输入流对象
          BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));
          //根据目的地创建字符输出流对象
          BufferedWriter bw = new BufferedWriter(new FileWriter("myOtherStream\\Copy.java"));
  
          //读写数据，复制文件
          String line;
          while ((line=br.readLine())!=null) {
              bw.write(line);
              bw.newLine();
              bw.flush();
          }
  
          //释放资源
          bw.close();
          br.close();
          */
  
          //根据数据源创建字符输入流对象
          BufferedReader br = new BufferedReader(new FileReader("操作文件\\ConversionStreamDemo01.java"));
          //根据目的地创建字符输出流对象
          PrintWriter pw = new PrintWriter(new FileWriter("操作文件\\Copy2.java"),true);
  
          //读写数据，复制文件
          String line;
          while ((line=br.readLine())!=null) {
              pw.println(line);
          }
  
          //释放资源
          pw.close();
          br.close();
      }
  }
  

7.6对象序列化流【应用】

• 对象序列化介绍

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

• 对象序列化流： ObjectOutputStream

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

• 构造方法

  方法名	说明
  ObjectOutputStream(OutputStream out)	创建一个写入指定的OutputStream的ObjectOutputStream

• 序列化对象的方法

  方法名	说明
  void writeObject(Object obj)	将指定的对象写入ObjectOutputStream

• 示例代码

  • 学生类

    package com.lxy.IO;
    
    import java.io.Serializable;
    
    public class Student3 implements Serializable {
        private String name;
        private int age;
    
        public Student3() {
        }
    
        public Student3(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 "Student3{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

  • 测试类

    package com.lxy.IO;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    
    public class ObjectOutputStreamDemo01 {
        public static void main(String[] args) throws IOException {
            //ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("操作文件\\oos.txt"));
    
            //创建对象
            Student3 s = new Student3("林青霞",30);
    
            //void writeObject(Object obj)：将指定的对象写入ObjectOutputStream
            oos.writeObject(s);
    
            //释放资源
            oos.close();
        }
    }
    

注意事项

• 一个对象要想被序列化，该对象所属的类必须必须实现Serializable 接口
• Serializable是一个标记接口，实现该接口，不需要重写任何方法

7.7对象反序列化流【应用】

• 对象反序列化流： ObjectInputStream

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

• 构造方法

  方法名	说明
  ObjectInputStream(InputStream in)	创建从指定的InputStream读取的ObjectInputStream

• 反序列化对象的方法

  方法名	说明
  Object readObject()	从ObjectInputStream读取一个对象

• 示例代码

package com.lxy.IO;

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

public class ObjectInputStreamDemo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("操作文件\\oos.txt"));

        //Object readObject()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student3 s = (Student3) obj;
        System.out.println(s.getName() + "," + s.getAge());

        ois.close();
    }
}

7.8serialVersionUID&transient【应用】

• serialVersionUID

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

• transient

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

• 示例代码

  • 学生类

    package com.lxy.IO;
    
    import java.io.Serializable;
    
    public class Student3 implements Serializable {
        private static final long serialVersionUID = 42L;
        private String name;
        //    private int age;
        private transient int age;
    
        public Student3() {
        }
    
        public Student3(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 "Student3{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

  • 测试类

    package com.lxy.IO;
    
    import java.io.*;
    
    public class ObjectStreamDemo01 {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            write();
            read();
        }
    
        //反序列化
        private static void read() throws IOException, ClassNotFoundException {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("操作文件\\oos.txt"));
            Object obj = ois.readObject();
            Student3 s = (Student3) obj;
            System.out.println(s.getName() + "," + s.getAge());
            ois.close();
        }
    
        //序列化
        private static void write() throws IOException {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("操作文件\\oos.txt"));
            Student3 s = new Student3("林青霞", 30);
            oos.writeObject(s);
            oos.close();
        }
    }
    

8.Properties集合

8.1Properties作为Map集合的使用【应用】

• Properties介绍

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

• Properties基本使用

  package com.lxy.properties;
  
  import java.util.Properties;
  import java.util.Set;
  
  public class PropertiesDemo01 {
      public static void main(String[] args) {
          //创建集合对象
  //        Properties<String,String> prop = new Properties<String,String>(); //错误
          Properties prop = new Properties();
  
          //存储元素
          prop.put("itheima001", "林青霞");
          prop.put("itheima002", "张曼玉");
          prop.put("itheima003", "王祖贤");
  
          //遍历集合
          Set<Object> keySet = prop.keySet();
          for (Object key : keySet) {
              Object value = prop.get(key);
              System.out.println(key + "," + value);
          }
      }
  }
  

8.2Properties作为Map集合的特有方法【应用】

• 特有方法

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

• 示例代码

  package com.lxy.properties;
  
  import java.util.Properties;
  import java.util.Set;
  
  public class PropertiesDemo02 {
      public static void main(String[] args) {
          //创建集合对象
          Properties prop = new Properties();
  
          //Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
          prop.setProperty("itheima001", "林青霞");
          /*
              Object setProperty(String key, String value) {
                  return put(key, value);
              }
  
              Object put(Object key, Object value) {
                  return map.put(key, value);
              }
           */
          prop.setProperty("itheima002", "张曼玉");
          prop.setProperty("itheima003", "王祖贤");
  
          //String getProperty(String key)：使用此属性列表中指定的键搜索属性
  //        System.out.println(prop.getProperty("itheima001"));
  //        System.out.println(prop.getProperty("itheima0011"));
  
  //        System.out.println(prop);
  
          //Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
          Set<String> names = prop.stringPropertyNames();
          for (String key : names) {
  //            System.out.println(key);
              String value = prop.getProperty(key);
              System.out.println(key + "," + value);
          }
      }
  }
  

8.3Properties和IO流相结合的方法【应用】

• 和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)方法的格式写入输出字符流

• 示例代码

  package com.lxy.properties;
  
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.util.Properties;
  
  public class PropertiesDemo03 {
      public static void main(String[] args) throws IOException {
          //把集合中的数据保存到文件
          myStore();
  
          //把文件中的数据加载到集合
          myLoad();
  
      }
  
      private static void myLoad() throws IOException {
          Properties prop = new Properties();
  
          //void load(Reader reader)：
          FileReader fr = new FileReader("操作文件\\fw.txt");
          prop.load(fr);
          fr.close();
  
          System.out.println(prop);
      }
  
      private static void myStore() throws IOException {
          Properties prop = new Properties();
  
          prop.setProperty("itheima001","林青霞");
          prop.setProperty("itheima002","张曼玉");
          prop.setProperty("itheima003","王祖贤");
  
          //void store(Writer writer, String comments)：
          FileWriter fw = new FileWriter("操作文件\\fw.txt");
          prop.store(fw,null);
          fw.close();
      }
  }
  

8.4游戏次数案例【应用】

• 案例需求

  • 实现猜数字小游戏只能试玩3次，如果还想玩，提示：游戏试玩已结束，想玩请充值

• 分析步骤

  1. 写一个游戏类，里面有一个猜数字的小游戏

  2. 写一个测试类，测试类中有main()方法，main()方法中写如下代码：

     ​ 从文件中读取数据到Properties集合，用load()方法实现

     文件已经存在：game.txt
     里面有一个数据值：count=0

     ​ 通过Properties集合获取到玩游戏的次数

     ​ 判断次数是否到到3次了

     如果到了，给出提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
     如果不到3次：
     次数+1，重新写回文件，用Properties的store()方法实现玩游戏

• 代码实现

  package com.lxy.properties;
  
  import java.util.Random;
  import java.util.Scanner;
  
  public class GuessNumber {
      public GuessNumber(){
  
      }
  
      public static void start(){
          Random random = new Random();
          int number = random.nextInt(100)+1;
          while (true){
              Scanner scanner = new Scanner(System.in);
              System.out.println("请输入你要猜的数字");
              int guessnumber = scanner.nextInt();
              if (guessnumber>number){
                  System.out.println("你猜的数字"+guessnumber+"大了");
              }else if(guessnumber<number){
                  System.out.println("你猜的数字"+guessnumber+"小了");
              }else {
                  System.out.println("恭喜你猜中了");
                  break;
              }
          }
      }
  }
  

  package com.lxy.properties;
  
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.util.Properties;
  
  public class PropertiesTest {
      public static void main(String[] args) throws IOException {
          //从文件中读取数据到Properties集合，用load()方法实现
          Properties prop = new Properties();
  
          FileReader fr = new FileReader("myOtherStream\\game.txt");
          prop.load(fr);
          fr.close();
  
          //通过Properties集合获取到玩游戏的次数
          String count = prop.getProperty("count");
          int number = Integer.parseInt(count);
  
          //判断次数是否到到3次了
          if(number >= 3) {
              //如果到了，给出提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
              System.out.println("游戏试玩已结束，想玩请充值(www.itcast.cn)");
          } else {
              //玩游戏
              GuessNumber.start();
  
              //次数+1，重新写回文件，用Properties的store()方法实现
              number++;
              prop.setProperty("count",String.valueOf(number));
              FileWriter fw = new FileWriter("myOtherStream\\game.txt");
              prop.store(fw,null);
              fw.close();
          }
      }
  }