属性集Properties 缓冲流Buffered 和 转换流 字节<--->字符

属性集 Properties
Jaba.util.Properties类继承于Hash table，用来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应的值都是一个字符串
构造方法
public Properties();创建一个空的属性集列表。
共性的API方法
public Object set Property(String key,String value);保存一对属性
public String get Property(String key);使用此属性列表中的指定的键搜索对应的值
public SetString Property Names();获取所有键的名称并封装到Set集合中

  //创建属性集对象
        Properties p = new Properties();
        //添加键值对元素
        p.setProperty("name","abc.txt");
        p.setProperty("size","12000");
        p.setProperty("destination","D:\jjjjjjjjjj.txt");
        p.put("date","小孙");
        //System.out.println(p);//{size=12000, name=abc.txt, destination=D:jjjjjjjjjj.txt}
        //通过键来获取值
        String date = p.getProperty("date");
        System.out.println(date);
        //遍历该属性集
        Set<String> strings = p.stringPropertyNames();
        //遍历keys

与流相关的方法
public void load(Input Stream input);从字节输入流中读取键值对
参数中使用了字节输入流，通过流对象，可以关联到某个文件上，这样就可以加载文件中的数据。文件中的数据的格式：
key=value

例如：
    data=小孙
    size=12000
    name=abc.txt

代码演示：

public static void show01() throws Exception {
        //构建一个流对象
        FileReader fi = new FileReader("a.txt");
        //1.创建Properties集合
        final Properties p2 = new Properties();
        //2使用Properties集合中的方法load读取保存在输入流中的数据
        p2.load(fi);
        //3遍历Properties集合
        Set<String> strings = p2.stringPropertyNames();
        for (String string : strings) {
            String s = p2.getProperty(string);
            System.out.println(string+"="+s);
        }
    }

public void store(OutputStream out,String comments);把集合当中数据写入字节输出流中可以使用Properties集合当中的方法store，把集合当中的临时数据，持久化写入到硬盘文件中保存。
代码示例：

 //1.创建Properties集合对象
        Properties properties = new Properties();
        properties.setProperty("四大名著1", "红楼梦");
        properties.setProperty("四大名著2", "西游记");
        properties.setProperty("四大名著3", "水浒传");
        properties.setProperty("四大名著4", "三国演义");
        // 2.创建字节输出流/字符输出流对象，构造方法中绑定需要写入数据的目的地
        FileWriter fw = new FileWriter("day29_IO\abcd.txt",true);
        //3.使用Properties集合中的store，把集合当中的临时数据持久化写入到硬盘文件当中
        properties.store(fw, "=四大名著");
        //4.释放资源
        fw.close();

缓冲流Buffered

缓冲流我们可以理解为对原来的使用数组方式进行数据传输的一种增强
按照类型分为：
字符缓冲流：BufferedReader，BufferedWriter
字节缓冲流：BufferedInputStream，BufferedOutputStream
缓冲流的基本原理，是在创建流对象的时候，回创建一个内置的默认大小的缓冲区数组，通过缓冲区的数据，减少系统的IO操作的次数，减少开销，提高程序的读写效率。
字节缓冲流
构造方法
public BufferedInputStream(InputStream input);创建一个新的缓冲输入流
public BufferedOutputStream(OutputStream output);创建一个新的缓冲输出流
代码示例：

public class Demo02BufferedInputStream {
    public static void main(String[] args) throws Exception {
        //1.创建一个FileInputStream流对象，构造方法中绑定需要写入数据源
        FileInputStream fis = new FileInputStream("one.txt");
        //2.创建BufferedInputStream对象，构造方法中传递FileInputStream流对象
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 3.使用BufferedInputStream对象中的方法read，把数据读取到内部缓冲区中
//        int len = 0;
//        while((len = bis.read())!=-1){
//            System.out.print((char) len);
//        }
        byte[] bytes = new byte[1024];
        int len = 0;//记录读取到的有效字节个数
        while((len = bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));//HelloWorld_Java
        }
        //4.释放资源
        bis.close();
    }
}

字符缓冲流

构造方法
public BufferedWriter(Writer out);创建一个新的字符缓冲输出流
public BufferedReader(Reader in);创建一个新的字符缓冲输入流
特有方法
BufferedReader：public String readLine();读取整行的文本信息
BufferedWriter：public void newLine（）；写入一行行分隔符，由系统属性定义换行符号。
字符缓冲输入流代码演示

//1.创建一个字符缓冲输入流对象，构造方法中传递一个字符输入流
        BufferedReader bw = new BufferedReader(new FileReader("c.txt"));
      //2.使用字符缓冲输入流对象中的read/readLine,读取文本信息
        //String s = bw.readLine();
        //System.out.println(s);//张HelloWorld
        //循环的结束条件 null readLine()返回值是null的时候
        String str =null;
        while((str=bw.readLine())!=null){
            System.out.println(str);
        }
        //3.释放资源
        bw.close();
    }

字符缓冲输出流

public static void main(String[] args) throws IOException {
        // 1.创建一个字符缓冲输出流对象，构造方法中传递一个字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("z.txt"));
        //2.调用字符缓冲输出流对象中的Write，把数据写入到内存缓冲区中
        bw.write("我今天学习了PS");
        bw.newLine();
        bw.write("3d软件mmd");
        bw.newLine();
        bw.write("c4d");
        //3.调用字符缓冲输出流对象中的flush方法，把内存缓冲区中的数据刷新到文件中
        bw.flush();
        // 4.释放资源
        bw.close();
    }

练习：文件复制

代码演示

public class Demo05CopyImageFile {

    public static void main(String[] args) throws Exception {
        show01();
        show02();

    }
    public  static void show02() throws Exception {
        //获取开始的时间
        long start = System.currentTimeMillis();
        //1.构建一个字节缓冲输入流
        BufferedInputStream bw = new BufferedInputStream(new FileInputStream("C:\Users\86175\Desktop\ss.png"));
        //2.构建一个字符缓冲输出流
        BufferedOutputStream bs = new BufferedOutputStream(new FileOutputStream("D:\2\ss.png"));
        //3.使用字节缓冲输入流对象的方法read，读取文件
        byte[] bytes = new byte[1024];
        //确定while循环结束的条件    read()==-1
        int len =0;//记录读取到的有效字节个数
        while ((len=bw.read(bytes))!=-1){
            //4.把读取到的字节内容再次写入到目的地文件中，调用write
            bs.write(bytes);
        }
        //5.释放资源
        bs.close();
        bw.close();
        //结束时耗费的时间
        long end = System.currentTimeMillis();
        System.out.println("耗费的时间为："+(end-start)+"ms");

    }



    //不使用缓冲流的操作
    public  static void show01() throws Exception {
        //获取开始的实际
        long start= System.currentTimeMillis();
        //1.构建字节输入流对象
        FileInputStream fis = new FileInputStream("C:\Users\86175\Desktop\ss.png");
        //2.构建一个字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\2\ss.png");
        //3.调用字节输入流对象中的方法read(byte[] b)读取文件
        byte[] bytes = new byte[1024];
        int len = 0;//记录读取到的有效字节个数
        while((len=fis.read(bytes))!=-1){
            //4.把读取到的字节内容写入到目的地文件中，调用writer(byte[] b)
            fos.write(bytes);
        }
        //5.释放资源
        fos.close();
        fis.close();
        //获取结束的时间
        long end = System.currentTimeMillis();
        System.out.println("文件耗费的时间为:"+(end-start)+"ms");
    }

}

转换流 字节流<--->字符流

字符编码：
按照某种规则，将字符存储到计算机中，称为编码；反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。在进行编码和节码过程中，我们必须采用同一种规则，才能数据正常，否则，回导致乱码现象。
字符集
字符集：是一个系统可支持的所有字符的集合，包括各国文字，标点符号，图形符号，数字等，也叫编码表
计算机中要准确存储和识别各种文字的字符符号，需要进行字符编码，一套字符集至少有一套字符编码
常见的字符编码及有ASCII字符集，GBK字符集、Unicode字符集。
ASCII字符集
ASCII是基于拉丁字母的一套编码系统，用于显示现代英语
基本的ASCII字符集，使用7为(bit)表示一个字符，共128个字符，ASCII的扩展字符集使用8位(bit)表示一个字符，共256个字符
ISO-8859-1字符集：
拉丁码表，别名--Latin-1，用于显示欧洲使用的语言，包括荷兰，丹麦，德语，意语，西班牙语等。
ISO-8859-1使用单字节码表，兼容ASCII编码。
GB字符集
GB2312：称为简体中文码表，里面大概含有7000多个简体汉字，此外一些数学符号，罗马希腊的字母，日俄不能的假名都编进去了，连在ASCII里的原来就有的数字、标点、字母都统统重新用2个字节编进去了
GBK：最常用的中文编码是在原来的GB2312码表基础上进行扩展，使用双字节编码，共收录了21000多个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩文字
GB18030：最小的中文码表，共收录了7万多个汉字，采用多字节编码，每个字可以由一个字节，2个字节或者4个字节组成，支持国内少数民族的文字。同时支持繁体字以及日韩汉字等
Unicode字符集：
Unicode编码系统位表达任意语言的任意字符而设计的，是业界的一种标准，也成为同一编码，标准万国码表。
它最多使用4个字节的数字来表示每个字母、符号、或者文字，由三种常见的便阿门方法：UTF-8,UTF-16,UTF-32
UTF-8编码表：用来表示Unicode标准中的任意字符，编码规则：
1.128个US-ASCII字符，使用的是一个字节编码
2.拉丁字等字母，选哟两个字节编码
3.大部分常见的汉字 使用的是三个字节编码
4.其他极少数辅助字符，采用的是四个字节编码
编码会引发的问题
由于编码规则不一致，导致引发乱码现象。
那么如何读取GBK编码的文件呢？
InputStreamReader类
转换流java.io.InputStreamReader是Reader的子类，它是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其节码为字符，它的字符集可以由名称指定，或者可以使用平台默认的字符集
构造方法
public InputStreamReader(InputStream in);创建一个使用默认的字符集的字符流。
public InputStreamReader(InputStream in,StringcharseName)创建一个指定字符集的字符流
代码演示：

  public void show02() throws Exception {
        //读取uTf-8
        InputStreamReader isr = new InputStreamReader(new FileInputStream("c.txt"), StandardCharsets.UTF_8);
        //2
        int len = 0;
        while((len=isr.read())!=-1){
            System.out.println((char)len);
        }
        isr.close();
    }

OutputStreamWriter类

转换流“java.io.OutputStreamWriter”是Writer的子类，它是字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以手动指定，也可以使用平台默认的字符集。

构造方法

• public OutputStreamWriter(OutputStream out);创建一个使用平台默认的字符集的字符流。
• public OutputStreamWriter(OutputStream out,String charsetName);创建一个指定的字符集的字符流。