day11-IO流,Properties集合,IO工具类

今日目标

  • IO流的介绍
  • IO流的分类
  • 字节输出流
  • 字节输入流
  • 字节缓冲区流
  • Properties集合

1 IO流的介绍

1.1 为什么要学习IO流

  • 通过变量,数组,或者集合存储数据

    • 都是不能永久化存储 , 因为数据都是存储在内存中
    • 只要代码运行结束，所有数据都会丢失

  • 使用IO流

    • 1，将数据写到文件中，实现数据永久化存储
    • 2，把文件中的数据读取到内存中(Java程序)

1.2 什么是IO流

  • I 表示intput ，是数据从硬盘进内存的过程，称之为读。
  • O 表示output ，是数据从内存到硬盘的过程。称之为写

  • IO的数据传输，可以看做是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作

    • 简单来说：内存在读，内存在写

1.3 IO流的分类

  • 按照流向区分

    • 输入流 : 用来读数据
    • 输出流 : 用来写数据

  • 按照类型区分

    • 字节流
    • 字符流

  • 注意 :

    • 字节流可以操作任意文件
    • 字符流只能操作纯文本文件
    • 用windows记事本打开能读的懂，那么这样的文件就是纯文本文件。

2 字节流输出流

2.1 字节输出流入门

  • FileOutputStream类 :
  • OutputStream有很多子类，我们从最简单的一个子类开始。
  • java.io.FileOutputStream类是文件输出流，用于将数据写出到文件
    • 构造方法 :
  • public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。

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

    1. public class FileOutputStreamConstructor throws IOException {
    2. public static void main(String[] args) {
    3.        // 使用File对象创建流对象
    4.    File file = new File("a.txt");
    5.    FileOutputStream fos = new FileOutputStream(file);
    7.    // 使用文件名称创建流对象
    8.    FileOutputStream fos = new FileOutputStream("b.txt");
    9. }
    10. }
  • 字节输出流写数据快速入门
  • 创建字节输出流对象。
  • 写数据
  • 释放资源 ```java package com.itheima.outputstream_demo;

import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;

/ 字节输出流写数据快速入门 : 1 创建字节输出流对象。 2 写数据 3 释放资源 / public class OutputStreamDemo1 { public static void main(String[] args) throws IOException { // 创建字节输出流对象 // 如果指定的文件不存在 , 会自动创建文件 // 如果文件存在 , 会把文件中的内容清空 FileOutputStream fos = new FileOutputStream(“day11_demo\a.txt”);

  1.     // 写数据
  2.     // 写到文件中就是以字节形式存在的
  3.     // 只是文件帮我们把字节翻译成了对应的字符 , 方便查看
  4.     fos.write(97);
  5.     fos.write(98);
  6.     fos.write(99);
  8.     // 释放资源
  9.     // while(true){}
  10.     // 断开流与文件中间的关系
  11.     fos.close();
  12. }

}

  2. <a name="a913834a"></a>
  3. ### 2.2 字节输出流写数据的方法
  5. - 
  6. 字节流写数据的方法
  8.    - 1 void write(int b)    一次写一个字节数据
  9.    - 2 void write(byte[] b)    一次写一个字节数组数据
  10.    - 3 void write(byte[] b, int off, int len)  一次写一个字节数组的部分数据
  11. ```java
  12. package com.itheima.outputstream_demo;
  14. import java.io.FileNotFoundException;
  15. import java.io.FileOutputStream;
  16. import java.io.IOException;
  18. /*
  19.     字节流写数据的3种方式
  20.         1 void write(int b)    一次写一个字节数据
  21.         2 void write(byte[] b)    一次写一个字节数组数据
  22.         3 void write(byte[] b, int off, int len)    一次写一个字节数组的部分数据
  23.  */
  24. public class OutputStreamDemo2 {
  25.     public static void main(String[] args) throws IOException {
  26.         // 创建字节输出流对象
  27.         FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt");
  29.         // 写数据
  30. //        1 void write(int b)    一次写一个字节数据
  31.         fos.write(97);
  32.         fos.write(98);
  33.         fos.write(99);
  35. //        2 void write(byte[] b)    一次写一个字节数组数据
  36.         byte[] bys = {65, 66, 67, 68, 69};
  37.         fos.write(bys);
  39. //        3 void write(byte[] b, int off, int len)    一次写一个字节数组的部分数据
  40.         fos.write(bys, 0, 3);
  42.         // 释放资源
  43.         fos.close();
  44.     }
  45. }

2.3 写数据的换行和追加写入

  1. package com.itheima.outputstream_demo;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  6. /*
  7.     字节流写数据的换行和追加写入
  9.     1 字节流写数据如何实现换行呢？
  10.         写完数据后，加换行符
  11.         windows : \r\n
  12.         linux : \n
  13.         mac : \r
  15.     2 字节流写数据如何实现追加写入呢？
  16.         通过构造方法 : public FileOutputStream(String name，boolean append)
  17.         创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容
  18.  */
  19. public class OutputStreamDemo3 {
  20.     public static void main(String[] args) throws IOException {
  21.         // 创建字节输出流对象
  22.         FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt");
  24.         // void write(int b)  一次写一个字节数据
  25.         fos.write(97);
  26.         // 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
  27.         fos.write("\r\n".getBytes());
  28.         fos.write(98);
  29.         fos.write("\r\n".getBytes());
  30.         fos.write(99);
  31.         fos.write("\r\n".getBytes());
  33.         // 释放资源
  34.         fos.close();
  35.     }
  36. }
  1. package com.itheima.outputstream_demo;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  6. /*
  7.     字节流写数据的换行和追加写入
  9.     1 字节流写数据如何实现换行呢？
  10.         写完数据后，加换行符
  11.         windows : \r\n
  12.         linux : \n
  13.         mac : \r
  15.     2 字节流写数据如何实现追加写入呢？
  16.         通过构造方法 : public FileOutputStream(String name，boolean append)
  17.         创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容
  18.  */
  19. public class OutputStreamDemo3 {
  20.     public static void main(String[] args) throws IOException {
  21.         // 创建字节输出流对象
  22.         // 追加写数据
  23.         // 通过构造方法 : public FileOutputStream(String name，boolean append) : 追加写数据
  24.         FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt" , true);
  26.         // void write(int b)    一次写一个字节数据
  27.         fos.write(97);
  28.         // 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
  29.         fos.write("\r\n".getBytes());
  30.         fos.write(98);
  31.         fos.write("\r\n".getBytes());
  32.         fos.write(99);
  33.         fos.write("\r\n".getBytes());
  35.         // 释放资源
  36.         fos.close();
  37.     }
  38.     // 写完数据换行操作
  39.     private static void method1() throws IOException {
  40.         // 创建字节输出流对象
  41.         FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt");
  43.         // void write(int b)    一次写一个字节数据
  44.         fos.write(97);
  45.         // 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
  46.         fos.write("\r\n".getBytes());
  47.         fos.write(98);
  48.         fos.write("\r\n".getBytes());
  49.         fos.write(99);
  50.         fos.write("\r\n".getBytes());
  52.         // 释放资源
  53.         fos.close();
  54.     }
  55. }

3 字节输入流

3.1 字节输入流介绍

  • 字节输入流类
  • InputStream类 : 字节输入流最顶层的类 , 抽象类
    —- FileInputStream类 : FileInputStream extends InputStream
    • 构造方法
  • public FileInputStream(File file) : 从file类型的路径中读取数据
  • public FileInputStream(String name) : 从字符串路径中读取数据
    • 步骤
  • 创建输入流对象
  • 读数据
  • 释放资源
    • ``` package com.itheima.inputstream_demo;

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

/ 字节输入流写数据快速入门 : 一次读一个字节 第一部分 : 字节输入流类 InputStream类 : 字节输入流最顶层的类 , 抽象类 —- FileInputStream类 : FileInputStream extends InputStream 第二部分 : 构造方法 public FileInputStream(File file) : 从file类型的路径中读取数据 public FileInputStream(String name) : 从字符串路径中读取数据 第三部分 : 字节输入流步骤 1 创建输入流对象 2 读数据 3 释放资源 / public class FileInputStreamDemo1 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 // 读取的文件必须存在 , 不存在则报错 FileInputStream fis = new FileInputStream(“day11_demo\a.txt”);

  1.     // 读数据 , 从文件中读到一个字节
  2.     // 返回的是一个int类型的字节
  3.     // 如果想看字符, 需要强转
  4.     int by = fis.read();
  5.     System.out.println((char) by);
  7.     // 释放资源
  8.     fis.close();
  9. }

}

  4. <a name="e864e190"></a>
  5. ### 3.2 字节输入流读多个字节

package com.itheima.inputstream_demo;

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

/ 字节输入流写数据快速入门 : 读多个字节 第一部分 : 字节输入流类 InputStream类 : 字节输入流最顶层的类 , 抽象类 —- FileInputStream类 : FileInputStream extends InputStream 第二部分 : 构造方法 public FileInputStream(File file) : 从file类型的路径中读取数据 public FileInputStream(String name) : 从字符串路径中读取数据 第三部分 : 字节输入流步骤 1 创建输入流对象 2 读数据 3 释放资源 / public class FileInputStreamDemo2 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 // 读取的文件必须存在 , 不存在则报错 FileInputStream fis = new FileInputStream(“day11_demo\a.txt”);

  1.     // 读数据 , 从文件中读到一个字节
  2.     // 返回的是一个int类型的字节
  3.     // 如果想看字符, 需要强转

// int by = fis.read(); // System.out.println(by); // by = fis.read(); // System.out.println(by); // by = fis.read(); // System.out.println(by); // // by = fis.read(); // System.out.println(by); // by = fis.read(); // System.out.println(by); // by = fis.read(); // System.out.println(by);

  1.     // 循环改进
  2.     int by;// 记录每次读到的字节
  3.     while ((by = fis.read()) != -1) {
  4.         System.out.print((char) by);
  5.     }
  7.     // 释放资源
  8.     fis.close();
  9. }

}

  2. <a name="d50d6463"></a>
  3. ### 3.3 图片的拷贝
  5. ```java
  6. package com.itheima.inputstream_demo;
  8. import java.io.FileInputStream;
  9. import java.io.FileNotFoundException;
  10. import java.io.FileOutputStream;
  11. import java.io.IOException;
  13. /*
  14.     需求 : 把 "图片路径\xxx.jpg" 复制到当前模块下
  16.     分析：
  17.         复制文件，其实就把文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
  18.         数据源：
  19.             xxx.jpg  --- 读数据 --- FileInputStream
  20.         目的地：
  21.             模块名称\copy.jpg --- 写数据 --- FileOutputStream
  23.  */
  24. public class FileInputStreamDemo2 {
  25.     public static void main(String[] args) throws IOException {
  26.         // 创建字节输入流对象
  27.         FileInputStream fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg");
  29.         // 创建字节输出流
  30.         FileOutputStream fos = new FileOutputStream("day11_demo\\copy.jpg");
  32.         // 一次读写一个字节
  33.         int by;
  34.         while ((by = fis.read()) != -1) {
  35.             fos.write(by);
  36.         }
  38.         // 释放资源
  39.         fis.close();
  40.         fos.close();
  41.     }
  42. }

3.4 异常的捕获处理

  • JDK7版本之前处理方式 : 手动释放资源
  1. package com.itheima.inputstream_demo;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. /*
  9.     需求 : 对上一个赋值图片的代码进行使用捕获方式处理
  10.  */
  11. public class FileInputStreamDemo4 {
  12.     public static void main(String[] args) {
  13.         FileInputStream fis = null ;
  14.         FileOutputStream fos = null;
  15.         try {
  16.             // 创建字节输入流对象
  17.             fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg");
  19.             // 创建字节输出流
  20.             fos = new FileOutputStream("day11_demo\\copy.jpg");
  22.             // 一次读写一个字节
  23.             int by;
  24.             while ((by = fis.read()) != -1) {
  25.                 fos.write(by);
  26.             }
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         } finally {
  30.             // 释放资源
  31.             if(fis != null){
  32.                 try {
  33.                     fis.close();
  34.                 } catch (IOException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.             }
  38.             // 释放资源
  39.             if(fos != null){
  40.                 try {
  41.                     fos.close();
  42.                 } catch (IOException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.         }
  47.     }
  48. }
  • JDK7版本优化处理方式 : 自动释放资源

  • JDK7优化后可以使用 try-with-resource 语句 , 该语句确保了每个资源在语句结束时自动关闭。
    简单理解 : 使用此语句,会自动释放资源 , 不需要自己在写finally代码块了

  • 格式 : ```java 格式 :
    try (创建流对象语句1 ; 创建流对象语句2 …) { // 读写数据 } catch (IOException e) { 处理异常的代码… }

举例 : try ( FileInputStream fis1 = new FileInputStream(“day11_demo\a.txt”) ; FileInputStream fis2 = new FileInputStream(“day11_demo\b.txt”) ) { // 读写数据 } catch (IOException e) { 处理异常的代码… }

  3. - 
  4. <a name="e8f77f2d"></a>
  5. ##### 代码实践
  7. ```java
  8. package com.itheima.inputstream_demo;
  10. import java.io.FileInputStream;
  11. import java.io.FileOutputStream;
  12. import java.io.IOException;
  14. /*
  15.     JDK7版本优化处理方式
  17.     需求 : 对上一个赋值图片的代码进行使用捕获方式处理
  18.  */
  19. public class FileInputStreamDemo5 {
  20.     public static void main(String[] args) {
  21.         try (
  22.                 // 创建字节输入流对象
  23.                 FileInputStream fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg");
  24.                 // 创建字节输出流
  25.                 FileOutputStream fos = new FileOutputStream("day11_demo\\copy.jpg")
  26.         ) {
  27.             // 一次读写一个字节
  28.             int by;
  29.             while ((by = fis.read()) != -1) {
  30.                 fos.write(by);
  31.             }
  32.             // 释放资源 , 发现已经灰色 , 提示多余的代码 , 所以使用 try-with-resource 方式会自动关流
  33.             // fis.close();
  34.             // fos.close();
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }

3.4 字节输入流一次读一个字节数组

  • FileInputStream类 :

    • public int read(byte[] b) : 从输入流读取最多b.length个字节的数据, 返回的是真实读到的数据个数 ```java package com.itheima.inputstream_demo;

import javax.sound.midi.Soundbank; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;

/ FileInputStream类 : public int read(byte[] b)： 1 从输入流读取最多b.length个字节的数据 2 返回的是真实读到的数据个数 / public class FileInputStreamDemo6 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 FileInputStream fis = new FileInputStream(“day11_demo\a.txt”);

// public int read(byte[] b)： // 1 从输入流读取最多b.length个字节的数据 // 2 返回的是真实读到的数据个数

  1.     byte[] bys = new byte[3];

// int len = fis.read(bys); // System.out.println(len);// 3 // System.out.println(new String(bys));// abc // // len = fis.read(bys); // System.out.println(len);// 2 // System.out.println(new String(bys));// efc

  1.     System.out.println("==========代码改进===============");

// int len = fis.read(bys); // System.out.println(len);// 3 // System.out.println(new String(bys, 0, len));// abc // // len = fis.read(bys); // System.out.println(len);// 2 // System.out.println(new String(bys, 0, len));// ef

  1.     System.out.println("==========代码改进===============");
  3.     int len;
  4.     while ((len = fis.read(bys)) != -1) {
  5.         System.out.print(new String(bys , 0 , len));
  6.     }
  8.     fis.close();
  9. }

}

  2. - 
  3. 对复制图片的代码进行使用一次读写一个字节数组的方式进行改进
  4. ```java
  5. package com.itheima.inputstream_demo;
  8. import java.io.FileInputStream;
  9. import java.io.FileNotFoundException;
  10. import java.io.FileOutputStream;
  11. import java.io.IOException;
  13. /*
  14.    需求 : 对复制图片的代码进行使用一次读写一个字节数组的方式进行改进
  16.    FileInputStream类 :
  17.        public int read(byte[] b)：
  18.        1 从输入流读取最多b.length个字节的数据
  19.        2 返回的是真实读到的数据个数
  20. */
  21. public class FileInputStreamDemo7 {
  22.    public static void main(String[] args) throws IOException {
  23.        // 创建字节输入流对象
  24.        FileInputStream fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg");
  25.        // 创建字节输出流
  26.        FileOutputStream fos = new FileOutputStream("day11_demo\\copy.jpg");
  28.        byte[] bys = new byte[1024];
  29.        int len;// 每次真实读到数据的个数
  30.        int by;
  31.        while ((len = fis.read(bys)) != -1) {
  32.            fos.write(bys, 0, len);
  33.        }
  35.        // 释放资源
  36.        fis.close();
  37.        fos.close();
  38.    }
  39. }

4 字节缓冲区流

4.1 字节缓冲流概述

  • 字节缓冲流：

    • BufferOutputStream：缓冲输出流
    • BufferedInputStream：缓冲输入流

  • 构造方法：

    • 字节缓冲输出流：BufferedOutputStream(OutputStream out)
    • 字节缓冲输入流：BufferedInputStream(InputStream in)

  • 为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

    • 字节缓冲流仅仅提供缓冲区，不具备读写功能 , 而真正的读写数据还得依靠基本的字节流对象进行操作

4.2 字节缓冲流案例

  1. package com.itheima.bufferedstream_demo;
  3. import java.io.*;
  5. /*
  6.     字节缓冲流：
  7.         BufferOutputStream：缓冲输出流
  8.         BufferedInputStream：缓冲输入流
  10.     构造方法：
  11.         字节缓冲输出流：BufferedOutputStream(OutputStream out)
  12.         字节缓冲输入流：BufferedInputStream(InputStream in)
  14.     为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
  15.         字节缓冲流仅仅提供缓冲区，不具备读写功能 , 而真正的读写数据还得依靠基本的字节流对象进行操作
  17.     需求 : 使用缓冲流进行复制文件
  19.  */
  20. public class BufferedStreamDemo1 {
  21.     public static void main(String[] args) throws IOException {
  22.         // 创建高效的字节输入流对象
  23.         // 在底层会创建一个长度为8192的数组
  24.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"));
  25.         // 创建高效的字节输出流
  26.         // 在底层会创建一个长度为8192的数组
  27.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\\copy.jpg"));
  29.         // 使用高效流 , 一次读写一个字节
  30.         int by;
  31.         while ((by = bis.read()) != -1) {
  32.             bos.write(by);
  33.         }
  35. //        byte[] bys = new byte[1024];
  36. //        int len;// 每次真实读到数据的个数
  37. //        while ((len = bis.read(bys)) != -1) {
  38. //            bos.write(bys, 0, len);
  39. //        }
  41.         // 释放资源
  42.         // 在底层会把基本的流进行关闭
  43.         bis.close();
  44.         bos.close();
  45.     }
  46. }

4.3 缓冲流一次读写一个字节原理

day10-字节流,递归 - 图1

4.4 缓冲流一次读写一个字节数组原理

day10-字节流,递归 - 图2

  • 四种方式复制视频文件
  1. package com.itheima.bufferedstream_demo;
  3. import java.awt.image.DataBufferDouble;
  4. import java.io.*;
  6. /*
  7.     需求：把“xxx.avi”复制到模块目录下的“copy.avi” , 使用四种复制文件的方式 , 打印所花费的时间
  9.     四种方式：
  10.         1 基本的字节流一次读写一个字节          : 花费的时间为:196662毫秒
  11.         2 基本的字节流一次读写一个字节数组      : 花费的时间为:383毫秒
  12.         3 缓冲流一次读写一个字节                : 花费的时间为:365毫秒
  13.         4 缓冲流一次读写一个字节数组            : 花费的时间为:108毫秒
  15.     分析 :
  16.         数据源 : "D:\a.wmv"
  17.         目的地 : "day11_demo\copy.wmv"
  18.  */
  19. public class BufferedStreamDemo2 {
  20.     public static void main(String[] args) throws IOException {
  21.         long startTime = System.currentTimeMillis();
  23.         // method1();
  24.         // method2();
  25.         // method3();
  26.         method4();
  28.         long endTime = System.currentTimeMillis();
  29.         System.out.println("花费的时间为:" + (endTime - startTime) + "毫秒");
  30.     }
  32.     // 4 缓冲流一次读写一个字节数组
  33.     private static void method4() throws IOException {
  34.         // 创建高效的字节输入流
  35.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.wmv"));
  36.         // 创建高效的字节输出流
  37.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\\copy.wmv"));
  39.         // 一次读写一个字节数组
  40.         byte[] bys = new byte[1024];
  41.         int len;// 每次真实读到数据的个数
  42.         while ((len = bis.read(bys)) != -1) {
  43.             bos.write(bys, 0, len);
  44.         }
  46.         // 释放资源
  47.         bis.close();
  48.         bos.close();
  49.     }
  51.     //  3 缓冲流一次读写一个字节
  52.     private static void method3() throws IOException {
  53.         // 创建高效的字节输入流
  54.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.wmv"));
  55.         // 创建高效的字节输出流
  56.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\\copy.wmv"));
  58.         // 一次读写一个字节
  59.         int by;
  60.         while ((by = bis.read()) != -1) {
  61.             bos.write(by);
  62.         }
  65.         // 释放资源
  66.         bis.close();
  67.         bos.close();
  68.     }
  70.     // 2 基本的字节流一次读写一个字节数组
  71.     private static void method2() throws IOException {
  72.         // 创建基本的字节输入流对象
  73.         FileInputStream fis = new FileInputStream("D:\\a.wmv");
  74.         // 创建基本的字节输出流对象
  75.         FileOutputStream fos = new FileOutputStream("day11_demo\\copy.wmv");
  77.         // 一次读写一个字节数组
  78.         byte[] bys = new byte[1024];
  79.         int len;// 每次真实读到数据的个数
  80.         while ((len = fis.read(bys)) != -1) {
  81.             fos.write(bys, 0, len);
  82.         }
  84.         // 释放资源
  85.         fis.close();
  86.         fos.close();
  87.     }
  89.     // 1 基本的字节流一次读写一个字节
  90.     private static void method1() throws IOException {
  91.         // 创建基本的字节输入流对象
  92.         FileInputStream fis = new FileInputStream("D:\\a.wmv");
  93.         // 创建基本的字节输出流对象
  94.         FileOutputStream fos = new FileOutputStream("day11_demo\\copy.wmv");
  96.         // 一次读写一个字节
  97.         int by;
  98.         while ((by = fis.read()) != -1) {
  99.             fos.write(by);
  100.         }
  102.         // 释放资源
  103.         fis.close();
  104.         fos.close();
  105.     }
  106. }

5.1 Properties集合的概述

  • properties是一个Map体系的集合类

    • public class Properties extends Hashtable <Object,Object>

  • 为什么在IO流部分学习Properties

    • Properties中有跟IO相关的方法

  • 当做双列集合使用

    • 不需要加泛型 , 工作中只存字符串 ```java package com.itheima.properties_demo;

import java.util.Map; import java.util.Properties; import java.util.Set;

/* 1 properties是一个Map体系的集合类

  1.     - `public class Properties extends Hashtable <Object,Object>`
  2. 2 为什么在IO流部分学习Properties
  3.     - Properties中有跟IO相关的方法
  4. 3 当做双列集合使用
  5.     - 不需要加泛型 , 工作中只存字符串

*/ public class PropertiesDemo1 { public static void main(String[] args) { // 创建集合对象 Properties properties = new Properties();

  1.     // 添加元素
  2.     properties.put("it001" , "张三");
  3.     properties.put("it002" , "李四");
  4.     properties.put("it003" , "王五");
  6.     // 遍历集合 : 键找值
  7.     Set<Object> set = properties.keySet();
  8.     for (Object key : set) {
  9.         System.out.println(key + "---" + properties.get(key));
  10.     }
  12.     System.out.println("========================");
  14.     // 遍历集合 : 获取对对象集合 , 获取键和值
  15.     Set<Map.Entry<Object, Object>> set2 = properties.entrySet();
  16.     for (Map.Entry<Object, Object> entry : set2) {
  17.         Object key = entry.getKey();
  18.         Object value = entry.getValue();
  19.         System.out.println(key + "---" + value);
  20.     }
  21. }

}

  2. <a name="a9badacc"></a>
  3. ### 5.2 Properties作为集合的特有方法
  5. - Object setProperty(String key, String value)    设置集合的键和值，都是String类型，相当于put方法
  6. - String getProperty(String key)    使用此属性列表中指定的键搜索属性 , 相当于get方法
  7. - Set stringPropertyNames()    从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串 , 相当于keySet方法
  9. ```java
  10. package com.itheima.properties_demo;
  12. import java.util.Properties;
  13. import java.util.Set;
  15. /*
  16.     Properties作为集合的特有方法
  17.         Object setProperty(String key, String value)    设置集合的键和值，都是String类型，相当于put方法
  18.         String getProperty(String key)    使用此属性列表中指定的键搜索属性 , 相当于get方法
  19.         Set<String> stringPropertyNames()    从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串 , 相当于keySet方法
  20.  */
  21. public class PropertiesDemo2 {
  23.     public static void main(String[] args) {
  24.         // 创建集合对象
  25.         Properties properties = new Properties();
  27.         // 添加元素
  28.         properties.setProperty("it001", "张三");
  29.         properties.setProperty("it002", "李四");
  30.         properties.setProperty("it003", "王五");
  32.         // 遍历集合 : 键找值
  33.         Set<String> set = properties.stringPropertyNames();
  34.         for (String key : set) {
  35.             System.out.println(key + "---" + properties.getProperty(key));
  36.         }
  37.     }
  38. }

5.3 properties中和IO相关的方法

  • void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
  • void load(Reader reader) 以字符流形式 , 把文件中的键值对, 读取到集合中
  • void store(OutputStream out, String comments) 把集合中的键值对,以字节流形式写入文件中 , 参数二为注释
  • void store(Writer writer, String comments) 把集合中的键值对,以字符流形式写入文件中 , 参数二为注释
  1. package com.itheima.properties_demo;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.util.Properties;
  7. /*
  8.    Properties和IO流结合的方法
  9.         void load(InputStream inStream)    以字节流形式 , 把文件中的键值对, 读取到集合中
  10.         //void load(Reader reader)    以字符流形式 , 把文件中的键值对, 读取到集合中
  11.         void store(OutputStream out, String comments)    把集合中的键值对,以字节流形式写入文件中 , 参数二为注释
  12.         //void store(Writer writer, String comments)    把集合中的键值对,以字符流形式写入文件中 , 参数二为注释
  13.  */
  14. public class PropertiesDemo3 {
  15.     public static void main(String[] args) throws IOException {
  16.         // 创建Properties集合对象
  17.         Properties properties = new Properties();
  19.         // void load(InputStream inStream)    以字节流形式 , 把文件中的键值对, 读取到集合中
  20.         properties.load(new FileInputStream("day11_demo\\prop.properties"));
  22.         // 打印集合中的数据
  23.         System.out.println(properties);
  24.     }
  25. }
  1. package com.itheima.properties_demo;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.util.Properties;
  8. /*
  9.    Properties和IO流结合的方法
  10.         void load(InputStream inStream)    以字节流形式 , 把文件中的键值对, 读取到集合中
  11.         //void load(Reader reader)    以字符流形式 , 把文件中的键值对, 读取到集合中
  12.         void store(OutputStream out, String comments)    把集合中的键值对,以字节流形式写入文件中 , 参数二为注释
  13.         //void store(Writer writer, String comments)    把集合中的键值对,以字符流形式写入文件中 , 参数二为注释
  14.  */
  15. public class PropertiesDemo3 {
  16.     public static void main(String[] args) throws IOException {
  17.         Properties properties = new Properties();
  18.         properties.setProperty("zhangsan" , "23");
  19.         properties.setProperty("lisi" , "24");
  20.         properties.setProperty("wangwu" , "25");
  21.         properties.store(new FileOutputStream("day11_demo\\prop2.properties") , "userMessage");
  22.     }
  24.     private static void method1() throws IOException {
  25.         // 创建Properties集合对象
  26.         Properties properties = new Properties();
  28.         // void load(InputStream inStream)    以字节流形式 , 把文件中的键值对, 读取到集合中
  29.         properties.load(new FileInputStream("day11_demo\\prop.properties"));
  31.         // 打印集合中的数据
  32.         System.out.println(properties);
  33.     }
  34. }

6 ResourceBundle加载属性文件

学习目标

  • 能够熟练使用ResourceBundle工具类快速读取属性文件的值

内容讲解

【1】API介绍

java.util.ResourceBundle它是一个抽象类，我们可以使用它的子类PropertyResourceBundle来读取以.properties结尾的配置文件。

通过静态方法直接获取对象：
  1. static ResourceBundle getBundle(String baseName) 可以根据名字直接获取默认语言环境下的属性资源。
  2. 参数注意: baseName 
  3.       1.属性集名称不含扩展名。
  4.     2.属性集文件是在src目录中的
  6. 比如：src中存在一个文件 user.properties
  7. ResourceBundle bundle = ResourceBundle.getBundle("user");

ResourceBundle中常用方法：

  1.  String getString(String key) : 通过键，获取对应的值

【2】代码实践

通过ResourceBundle工具类

将一个属性文件 放到src目录中，使用ResourceBundle去获取键值对数据

  1. package com.itheima.resourcebundle_demo;
  3. import java.util.ResourceBundle;
  5. /*
  6.     1   java.util.ResourceBundle : 它是一个抽象类
  7.         我们可以使用它的子类PropertyResourceBundle来读取以.properties结尾的配置文件
  9.     2   static ResourceBundle getBundle(String baseName) 可以根据名字直接获取默认语言环境下的属性资源。
  10.         参数注意: baseName
  11.             1.属性集名称不含扩展名。
  12.             2.属性集文件是在src目录中的
  13.         比如：src中存在一个文件 user.properties
  14.         ResourceBundle bundle = ResourceBundle.getBundle("user");
  16.     3 ResourceBundle中常用方法：
  17.          String getString(String key) : 通过键，获取对应的值
  19.     优点 : 快速读取属性文件的值
  21.      需求 :
  22.         通过ResourceBundle工具类
  23.         将一个属性文件 放到src目录中，使用ResourceBundle去获取键值对数据
  24.  */
  25. public class ResourceBundleDemo {
  26.     public static void main(String[] args) {
  27.         // public static final ResourceBundle getBundle(String baseName)
  28.         // baseName : properties文件的名字 , 注意 : 扩展名不需要加上 , properties必须在src的根目录下
  29.         ResourceBundle resourceBundle = ResourceBundle.getBundle("user");
  31.         // String getString(String key) : 通过键，获取对应的值
  32.         String value1 = resourceBundle.getString("username");
  33.         String value2 = resourceBundle.getString("password");
  34.         System.out.println(value1);
  35.         System.out.println(value2);
  36.     }
  37. }

内容小结

  1. 如果要使用ResourceBundle加载属性文件，属性文件需要放置在哪个位置？
    1. src的根目录
  1. 请描述使用ResourceBundle获取属性值的大致步骤是怎样的？
    1. 1 获取ResourceBundle对象
    2. 2 通过ResourceBundle类中的getString(key) : 根据键找值