一、文件

文件流 ：文件在程序中以流的形式来操作
输入流：数据从数据源（文件）到程序（内存）的路径
输出流：数据从程序（内存）到数据源（文件）的路径

1.1 创建文件

构造器：

  1. new File(String pathname) 根据路径构建一个File对象
  2. new File(String parent,String child) 根据父目录文件+子路径构建

  3. new File(String parent,String child) 根据父目录+子路径构建

    1. public class FileCreate {
    2.  public static void main(String[] args) {
    4.  }
    5.  // 1. new File(String pathname)
    6.  @Test
    7.  public void create1() {
    8.      String filePath = "C:\\Users\\ace\\Desktop\\test\\news1.txt";
    9.      File file = new File(filePath);
    11.      try {
    12.          file.createNewFile();
    13.          System.out.println("文件创建成功");
    14.      } catch (IOException exception) {
    15.          exception.printStackTrace();
    16.      }
    17.  }
    18.  // 2. new File(File parent,String child) 根据父目录文件+子路径构建
    19.  @Test
    20.  public void create2() {
    21.      File parentFile = new File("C:\\Users\\ace\\Desktop\\test\\");
    22.      String fileName = "news2.txt";
    23.      File file = new File(parentFile, fileName);
    24.      try {
    25.          file.createNewFile();
    26.          System.out.println("文件创建成功");
    27.      } catch (IOException exception) {
    28.          exception.printStackTrace();
    29.      }
    30.  }
    31.  // 3. new File(String parent,String child) 根据父目录+子路径构建
    32.  @Test
    33.  public void create3() {
    34.      String parentPath = "C:\\Users\\ace\\Desktop\\test\\";
    35.      String fileName = "news3.txt";
    36.      File file = new File(parentPath, fileName);
    37.      try {
    38.          file.createNewFile();
    39.          System.out.println("文件创建成功");
    40.      } catch (IOException exception) {
    41.          exception.printStackTrace();
    42.      }
    43.  }
    44. }

    1.2 获取文件的相关信息

    1. public class FileInformation {
    2.  // 获取文件信息
    3.  @Test
    4.  public void info() {
    5.      // 创建文件对象
    6.      String filePath = "C:\\Users\\ace\\Desktop\\test\\news3.txt";
    7.      File file = new File(filePath);
    8.      // 文件名
    9.      System.out.println(file.getName()); //news3.txt
    10.      // 绝对路径
    11.      System.out.println(file.getAbsolutePath()); //C:\Users\ace\Desktop\test\news3.txt
    12.      // 父级目录
    13.      System.out.println(file.getParent()); // C:\Users\ace\Desktop\test
    14.      // 文件大小（字节）
    15.      System.out.println(file.length()); // 5
    16.      // 文件是否存在
    17.      System.out.println(file.exists()); // true
    18.      // 是不是一个文件
    19.      System.out.println(file.isFile()); // true
    20.      // 是不是一个目录
    21.      System.out.println(file.isDirectory()); // false
    22.  }
    23. }

    1.3 文件删除、目录操作

    ```java public class Directory_ { // 判断文件是否存在，存在就删除 @Test public void m1() {

    1.  String filePath = "C:\\Users\\ace\\Desktop\\test\\news3.txt";
    2.  File file = new File(filePath);
    3.  if(file.exists()) {
    4.      if (file.delete()) {
    5.          System.out.println("删除成功");
    6.      } else {
    7.          System.out.println("删除失败");
    8.      }
    9.  } else {
    10.      System.out.println("文件不存在");
    11.  }

    } // 判断目录是否存在，存在就删除 @Test public void m2() {

    1.  String dirPath = "C:\\Users\\ace\\Desktop\\test\\demo";
    2.  File file = new File(dirPath);
    3.  if(file.exists()) {
    4.      if (file.delete()) {
    5.          System.out.println("删除成功");
    6.      } else {
    7.          System.out.println("删除失败");
    8.      }
    9.  } else {
    10.      System.out.println("目录不存在");
    11.  }

    } // 判断目录是否存在，不存在就创建 @Test public void m3() {

    1.  String dirPath = "C:\\Users\\ace\\Desktop\\test\\demo\\demo1";
    2.  File file = new File(dirPath);
    3.  if(file.exists()) {
    4.      System.out.println("目录存在");
    5.  } else {
    6.      // 多级目录创建不能用file.mkdir()
    7.      if(file.mkdirs()) {
    8.          System.out.println("创建成功");
    9.      } else {
    10.          System.out.println("创建失败");
    11.      }
    12.  }

    } }

  1. <a name="Oxi8x"></a>
  2. ## 二、IO流
  4. 1. java数据的输入/输出操作以流的方式进行
  5. 1. 分类：
  6.    1. 按操作数据单位不同分为：字节流二进制文件，字符流文本文件
  7.    1. 按数据流的流向不同分为：输入流、输出流
  8.    1. 按流的角色的不同分为：节点流、处理流/包装流
  10. InputStream 字节输入流<br />常用子类：
  12. - FileInputStream 文件输入流
  13. - BufferedInputStream 缓冲字节输入流
  14. - ObjectInputStream 对象字节输入流
  16. ![aaa.png](https://cdn.nlark.com/yuque/0/2022/png/26273875/1647162668172-d6f26219-3727-4569-b09e-c20657ae13bb.png#clientId=ueb5858fc-50d6-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=u4f1a5d62&margin=%5Bobject%20Object%5D&name=aaa.png&originHeight=467&originWidth=788&originalType=binary&ratio=1&rotation=0&showTitle=false&size=23722&status=done&style=none&taskId=u519b11b3-b725-4ce6-bbf3-a5249abe549&title=)
  17. <a name="lA9Vc"></a>
  18. ### 2.1 字节输入输出流
  19. <a name="x0hVD"></a>
  20. #### 2.1.1 FileInputStream
  21. ```java
  22. // 字节输入流
  23. public class FileInputStream_ {
  24.     // 单个字节
  25.     @Test
  26.     public void read1() throws IOException {
  27.         String filePath = "C:\\Users\\ace\\Desktop\\hello.txt";
  28.         int readData = 0;
  29.         FileInputStream fileInputStream = null;
  30.         try {
  31.             // FileInputStream对象用于读取文件
  32.             fileInputStream = new FileInputStream(filePath);
  33.             // 从输入流读一个字节，没有输入，此方法将阻止；返回-1，读取完毕
  34.             while ((readData = fileInputStream.read()) != -1) {
  35.                 System.out.print((char) readData);
  36.             }
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         } finally {
  40.             // 关闭文件流 释放资源
  41.             fileInputStream.close();
  42.         }
  43.     }
  44.     // 使用read(byte[] b)读取文件 提高效率
  45.     @Test
  46.     public void read2() throws IOException {
  47.         String filePath = "C:\\Users\\ace\\Desktop\\hello.txt";
  48.         // 字节数组
  49.         byte[] buf = new byte[8]; // 一次读取8个
  50.         int readLen = 0;
  51.         FileInputStream fileInputStream = null;
  52.         try {
  53.             // FileInputStream对象用于读取文件
  54.             fileInputStream = new FileInputStream(filePath);
  55.             // 从输入流读最多读取b.length字节的数据到字节数组
  56.             // 返回实际读取的字节数
  57.             while ((readLen = fileInputStream.read(buf)) != -1) {
  58.                 System.out.print(new String(buf,0, readLen));
  59.             }
  61.         } catch (IOException e) {
  62.             e.printStackTrace();
  63.         } finally {
  64.             // 关闭文件流 释放资源
  65.             fileInputStream.close();
  66.         }
  67.     }
  68. }

2.1.2 FileOutputStream

![@JCPK4Z_VJ~9@(2[]{%W2Y.png

  1. public class FileOutputStream_ {
  2.     @Test
  3.     public void write1() {
  4.         String filePath = "C:\\Users\\ace\\Desktop\\hello1.txt";
  5.         FileOutputStream fileOutputStream = null;
  6.         try {
  7.             // new FileOutputStream(filePath)覆盖原来的内容
  8.             // new FileOutputStream(filePath, true)追加 append为true
  9.             fileOutputStream = new FileOutputStream(filePath);
  10.             // 1. 写入一个字节
  11.             fileOutputStream.write('H');
  12.             // 2. 写入字符串
  13.             String str = "hello,world!";
  14.             // getBytes将字符串转字节数组
  15.             fileOutputStream.write(str.getBytes(StandardCharsets.UTF_8));
  16.             // 3. 写入指定偏移量和长度的字节数组
  17.             fileOutputStream.write(str.getBytes(StandardCharsets.UTF_8), 0, str.length());
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         } finally {
  22.             try {
  23.                 fileOutputStream.close();
  24.             } catch (IOException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         }
  28.     }
  29. }

2.1.3 文件拷贝

  1. // 文件拷贝
  2. public class FileCopy {
  3.     public static void main(String[] args) {
  4.         String srcFilePath = "C:\\Users\\ace\\Desktop\\aaa.png";
  5.         String destFilePath = "C:\\Users\\ace\\Desktop\\bbb.png";
  6.         FileInputStream fileInputStream = null;
  7.         FileOutputStream fileOutputStream = null;
  8.         try {
  9.             fileInputStream = new FileInputStream(srcFilePath);
  10.             fileOutputStream = new FileOutputStream(destFilePath);
  11.             // 定义一个字节数组
  12.             byte[] buff = new byte[1024];
  13.             int readLen = 0;
  14.             while ((readLen = fileInputStream.read(buff)) != -1) {
  15.                 fileOutputStream.write(buff,0,readLen);
  16.                 // fileOutputStream.write(buff) 可能会不够1024 图片出错
  17.             }
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         } finally {
  21.             try {
  22.                 // 关闭输入流输出流
  23.                 if (fileInputStream != null) {
  24.                     fileInputStream.close();
  25.                 }
  26.                 if (fileOutputStream != null) {
  27.                     fileOutputStream.close();
  28.                 }
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  34.     }
  35. }

2.2 FileReader和FileWriter

RM%11)UJ_2CVM5T9A{JU8_Y.pngVBZVIVDQ~0J$MHLO4RM6WHQ.png

2.2.1 FileReader

new FileReader(File/String)
read 每次读取单个字符，返回该字符，到文件末尾返回-1
read(char[]) 批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1

  1. public class FileReader_ {
  2.     public static void main(String[] args) {}
  3.     /* 单个字符读取文件*/
  4.     public void read() {
  5.         String filePath = "C:\\Users\\ace\\Desktop\\hello1.txt";
  6.         FileReader fileReader = null;
  7.         int data = ' ';
  8.         try {
  9.             fileReader = new FileReader(filePath);
  10.             // 单个字符读取
  11.             while ((data = fileReader.read()) != -1) {
  12.                 System.out.print((char) data);
  13.             }
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         } finally {
  17.             try {
  18.                 if(fileReader != null) {
  19.                     fileReader.close();
  20.                 }
  21.             } catch (IOException e) {
  22.                 e.printStackTrace();
  23.             }
  25.         }
  26.     }
  27.     /* 字符数组读取文件*/
  28.     @Test
  29.     public void read1() {
  30.         String filePath = "C:\\Users\\ace\\Desktop\\hello1.txt";
  31.         FileReader fileReader = null;
  32.         int readLen = 0;
  33.         char[] buf = new char[8];
  34.         try {
  35.             fileReader = new FileReader(filePath);
  36.             // read返回实际读取到的字符数
  37.             while ((readLen = fileReader.read(buf)) != -1) {
  38.                 System.out.print(new String(buf, 0, readLen));
  39.             }
  40.         } catch (IOException e) {
  41.             e.printStackTrace();
  42.         } finally {
  43.             try {
  44.                 if(fileReader != null) {
  45.                     fileReader.close();
  46.                 }
  47.             } catch (IOException e) {
  48.                 e.printStackTrace();
  49.             }
  51.         }
  52.     }
  53. }

2.2.2 FileWriter

new FileWriter(File/String) 覆盖旧文件写入
new FileWriter(File/String,true) 追加模式写入
write(int) 写入单个字符
write(char[]) 写入指定数组
write(char[],off,len) 写入指定数组的指定部分
write(String) 写入整个字符串
write(String,off,len) 写入字符串的指定部分
必须要close或flush否则写入不到指定的文件 

  1. public class FileWriter_ {
  2.     public static void main(String[] args) {
  3.         String filePath = "C:\\Users\\ace\\Desktop\\test.txt";
  4.         FileWriter fileWriter = null;
  5.         char[] chars = {'a', 'b', 'c'};
  6.         try {
  7.             fileWriter = new FileWriter(filePath);
  8.             // 覆盖
  9.             // 写入单个字符
  10.             //fileWriter.write('H');
  11.             // 写入指定数组
  12.             //fileWriter.write(chars);
  13.             // 写入数组指定部分
  14.             fileWriter.write("llllawsjai".toCharArray(),0,5);
  15.             // 写入整个字符串
  16.             fileWriter.write("llllawsjai ");
  17.             // 写入字符串某个部分
  18.             fileWriter.write("llllawsjai",0,2);
  19.             // 数据量大，可以使用循环操作
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         } finally {
  24.             // FileWriter 要 close 或 flush 才能把数据写入到文件
  25.             try {
  26.                 fileWriter.close();
  27.             } catch (IOException e){
  28.                 e.printStackTrace();
  29.             }
  30.         }
  31.     }
  32. }

2.3 节点流和处理流

  1. 节点流可以从一个特定的数据源读写数据
  2. 处理流（包装流）是连接再已经存在的节点流或处理流之上
  3. 节点流是底层流/低级流，直接跟数据源相接
  4. 处理流（包装流）包装结点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入和输出

  5. 处理流对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连

    2.3.1 处理流——BufferedReader和BufferedWriter

    BufferedReader和BufferedWriter属于字符流 关闭处理流时，只需要关闭外层流

    2.3.1.1 BufferedReader
    1. public class BufferedReader1 {
    2.  public static void main(String[] args) throws IOException {
    3.      String filePath = "C:\\Users\\ace\\Desktop\\test.txt";
    4.      BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
    5.      // 读取
    6.      String line; // 按行读取
    7.      // 返回null时，表示文件读取完成
    8.      while ((line = bufferedReader.readLine()) != null) {
    9.          System.out.println(line);
    10.      }
    11.      // 关闭流 只需要关闭BufferedReader,底层会自动关闭节点流
    12.      bufferedReader.close();
    13.  }
    14. }

    2.3.1.2 BufferedWriter
    1. public class BufferedWriter1 {
    2.  public static void main(String[] args) throws IOException {
    3.      String filePath = "C:\\Users\\ace\\Desktop\\test1.txt";
    4.      // new FileWriter(filePath, true) 表示以追加的方式写入
    5.      // 覆盖
    6.      BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
    7.      bufferedWriter.write("hello1");
    8.      bufferedWriter.newLine();// 插入换行符,具体是什么取决于系统
    9.      bufferedWriter.write("hello2");
    10.      bufferedWriter.write("hello3");
    11.      bufferedWriter.write("hello4");
    13.      // 关闭外层流
    14.      bufferedWriter.close();
    15.  }
    16. }

    2.3.1.3 文件拷贝
    1. public class BufferedCopy {
    2.  public static void main(String[] args) {
    3.      // BufferedReader和BufferedWriter按字符操作 操作二进制文件可能文件损坏
    4.      String srcPath = "C:\\Users\\ace\\Desktop\\test1.txt";
    5.      String destPath = "C:\\Users\\ace\\Desktop\\test2.txt";
    6.      BufferedReader bufferedReader = null;
    7.      BufferedWriter bufferedWriter = null;
    8.      String line;
    9.      try {
    10.          bufferedReader = new BufferedReader(new FileReader(srcPath));
    11.          bufferedWriter = new BufferedWriter(new FileWriter(destPath));
    12.          // readLine 读一行内容但没有换行符
    13.          while ((line = bufferedReader.readLine()) != null) {
    14.              bufferedWriter.write(line);
    15.              bufferedWriter.newLine();
    16.          }
    17.      } catch (IOException e) {
    18.          e.printStackTrace();
    19.      } finally {
    20.          try {
    21.              // 关闭流
    22.              if(bufferedReader != null) {
    23.                  bufferedReader.close();
    24.              }
    25.              if(bufferedWriter != null) {
    26.                  bufferedWriter.close();
    27.              }
    28.          } catch (IOException e) {
    29.              e.printStackTrace();
    30.          }
    32.      }
    34.  }
    35. }

    2.3.2 处理流——BufferedInputStream 和 BufferedOutputStream

    ![0Q683FFSH3%1OGR6GLZYHX.png_0Q%9DSA27M}HTY_W@LUGVU.png
    BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲区数组
    BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，不必对每次字节写入调用底层

    1. public class BufferedCopy02 {
    2.  // 字节流可以操作二进制文件也可以操作文本文件
    3.  public static void main(String[] args) {
    4.      String srcPath = "C:\\Users\\ace\\Desktop\\aaa.png";
    5.      String destPath = "C:\\Users\\ace\\Desktop\\ccc.png";
    6.      BufferedInputStream bufferedInputStream = null;
    7.      BufferedOutputStream bufferedOutputStream = null;
    8.      try {
    9.          bufferedInputStream = new BufferedInputStream(new FileInputStream(srcPath));
    10.          bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destPath));
    11.          // 循环读取文件，写入
    12.          byte[] buff = new byte[1024];
    13.          int readLen = 0;
    14.          while ((readLen = bufferedInputStream.read(buff)) != -1) {
    15.              bufferedOutputStream.write(buff,0, readLen);
    16.          }
    17.      } catch (IOException e) {
    18.          e.printStackTrace();
    19.      } finally {
    20.          try {
    21.              if(bufferedInputStream != null){
    22.                  bufferedInputStream.close();
    23.              }
    24.              if (bufferedOutputStream != null) {
    25.                  bufferedOutputStream.close();
    26.              }
    27.          } catch (IOException e) {
    28.              e.printStackTrace();
    29.          }
    30.      }
    31.  }
    32. }

    2.3.3 对象流——ObjectInputStream 和 ObjectOutputStream

    `B`{~TF1{~I%E8G22SR@{_J.pngP7MOKNRMWJS`$42ZX4~G7DE.png
    对象流提供了对基本类型或对象类型的序列化和反序列化的方法
    序列化和反序列化：

  6. 序列化是在保存数据时，保存数据的值和数据类型

  7. 反序列化在恢复数据时，恢复数据的值和数据类型

  8. 需要让某个对象支持序列化机制，就必须让其类是可序列化的，必须实现以下两个接口之一：

    1. Serializable 是一个标记接口，没有方法

    2. Externalizable 该接口有方法需要实现，因此一般实现a

      2.3.3.1 ObjectOutputStream 序列化
      1. public class ObjectOutStream1 {
      2. public static void main(String[] args) throws Exception{
      3.   // 序列化后保存的文件格式不是纯文本
      4.   String filePath = "C:\\Users\\ace\\Desktop\\data.dat";
      5.   ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
      6.   // 序列化数据到文件
      7.   objectOutputStream.writeInt(100); // int->Integer 实现了Serializable
      8.   objectOutputStream.writeBoolean(true); // boolean->Boolean
      9.   objectOutputStream.writeChar('a'); // char->Character
      10.   objectOutputStream.writeDouble(8.5); // double->Double
      11.   objectOutputStream.writeUTF("星期六"); // String
      12.   // 保存一个dog对象
      13.   objectOutputStream.writeObject(new Dog("狗子", 10));
      14.   objectOutputStream.close();
      15. }
      16. }
      17. class Dog implements Serializable {
      18. private String name;
      19. private int age;
      20. // 序列化版本号，提高版本兼容性
      21. private static final long serialVersionUID = 1L;
      22. public Dog(String name, int age) {
      23.   this.name = name;
      24.   this.age = age;
      25. }
      27. @Override
      28. public String toString() {
      29.   return "Dog{" +
      30.           "name='" + name + '\'' +
      31.           ", age=" + age +
      32.           '}';
      33. }
      34. }

      2.3.3.2 ObjectInputStream 反序列化
      1. public class ObjectInputStream1 {
      2. public static void main(String[] args) throws IOException, ClassNotFoundException {
      3.   // 指定反序列化的文件
      4.   String filePath = "C:\\Users\\ace\\Desktop\\data.dat";
      5.   ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
      6.   // 反序列化顺序需要和保存数据的顺序一致
      7.   System.out.println(objectInputStream.readInt());
      8.   System.out.println(objectInputStream.readBoolean());
      9.   System.out.println(objectInputStream.readChar());
      10.   System.out.println(objectInputStream.readDouble());
      11.   System.out.println(objectInputStream.readUTF());
      12.   Object dog = objectInputStream.readObject();
      13.   System.out.println(dog);
      14.   // 要调用Dog方法，需要向下转型
      15.   // 需要Dog类的定义，放在可引用的位置
      16.   // 序列化对象时，要求里面属性的类型也需要实现序列化接口
      17.   // 序列化具备可继承性，即如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
      18.   dog = (Dog) dog;
      19.   objectInputStream.close();
      20. }
      21. }

      2.3.4 标准输入输出流

      | | 类型 | 默认设备 | | —- | —- | —- | | System.in 标准输入 | InputStream | 键盘 | | System.out 标准输出 | PrintStream | 显示器 |

2.3.5 转换流——InputStreamReader 和 OutputStreamWriter

  • 可能存在中文乱码

    1. public class CodeQuestion {
    2.   public static void main(String[] args) throws IOException {
    3.       // 默认读取文件编码UTF-8 不是此编码方式中文可能乱码
    4.       String filePath = "C:\\Users\\ace\\Desktop\\test1.txt";
    5.       BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
    6.       String s = bufferedReader.readLine();
    7.       System.out.println(s);
    8.       bufferedReader.close();
    9.   }
    10. }

    InputStreamReader，Reader的子类，可以将InputStream（字节流）包装成Reader（字符流）
    OutputStreamWriter，Writer的子类，实现将OutputStream（字节流）包装成Writer（字符流）

    1. public class InputStreamReader1 {
    2.   public static void main(String[] args) throws IOException {
    3.       String filePath = "C:\\Users\\ace\\Desktop\\test1.txt";
    4.       // FileInputStream转成InputStreamReader 并指定编码gbk
    5.       InputStreamReader gbk = new InputStreamReader(new FileInputStream(filePath), "gbk");
    6.       // 把InputStreamReader传入BufferedReader
    7.       BufferedReader bufferedReader = new BufferedReader(gbk);
    8.       // 写成 BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
    9.       String s = bufferedReader.readLine();
    10.       System.out.println(s);
    11.       bufferedReader.close();
    12.   }
    13. }
    1. public class OutputStreamWriter1 {
    2.   public static void main(String[] args) throws IOException {
    3.       String filePath = "C:\\Users\\ace\\Desktop\\test2.txt";
    4.       String charSet = "gbk";
    5.       OutputStreamWriter gbk = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
    6.       gbk.write("fdsfdfda");
    7.       gbk.close();
    8.   }
    9. }

    2.4 打印流——PrintStream和PrintWriter

    ![DVJIAHRGG%W]I0437~UFIW.pngTFC61EI7_0OM89~R4@X17VS.png

    1. public class PrintStream1 {
    2.   public static void main(String[] args) throws IOException {
    3.       PrintStream out = System.out;
    4.       // 默认情况下，PrintStream输出数据的位置是标准输出（显示器）
    5.       out.print("ddd");
    6.       // print底层是write，可以直接调用write
    7.       out.write("你好".getBytes(StandardCharsets.UTF_8));
    8.       // 修改打印输出流的设备/位置,输出到文件中
    9.       System.setOut(new PrintStream("C:\\Users\\ace\\Desktop\\test2.txt"));
    10.       System.out.println("aaa");
    11.       out.close();
    12.   }
    13. }
    1. public class PrinterWriter1 {
    2.   public static void main(String[] args) throws FileNotFoundException {
    3.       PrintWriter printWriter = new PrintWriter(System.out); // 标准输出
    4.       PrintWriter printWriter1 = new PrintWriter("C:\\Users\\ace\\Desktop\\test2.txt"); // 输出到文件
    5.       printWriter.print("hfish");
    6.       printWriter1.print("fwff");
    7.       printWriter.close();
    8.       printWriter1.close(); // 关闭流或flush才会写入文件
    9.   }
    10. }

    2.5 Properties类

    配置文件：
    键=值
    不要空格、引号，默认是String
    常用方法：
    load 加载配置文件的键值对到Properties对象
    list 将数据显示到指定设备
    getProperty(key) 根据键获取值
    setProperty(key,value) 设置键值对到Properties对象
    store 将Properties中的键值对存储到配置文件，idea中文存储为unicode

    1. public class Properties0 {
    2.   public static void main(String[] args) throws IOException {
    3.       Properties properties = new Properties();
    4.       properties.load(new FileReader("src\\mysql.properties"));
    5.       // k-v显示
    6.       properties.list(System.out);
    7.       // 根据k获取v
    8.       String id = properties.getProperty("id");
    9.       System.out.println(id);
    10.   }
    11. }
    1. public class Properties02 {
    2.   public static void main(String[] args) throws IOException {
    3.       Properties properties = new Properties();
    4.       // 创建
    5.       // 文件中没有该k就是创建，有就是修改
    6.       properties.setProperty("ip", "127.0.0.1");
    7.       properties.setProperty("name", "ranranarn"); // 中文保存unicode码
    8.       // 将k-v存储到文件中
    9.       properties.store(new FileOutputStream("src\\mysql2.properties"), null);
    11.   }
    12. }