（java总结）Buffered IO缓冲区读取数据

package Demo45;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/**
 * java.util.Properties集合 extends Hash<k,v> implement Map<k,v>
 * Properties类表示了一个持久的属性集。Properties可保存在流中或从流中加载
 * Properties集合是唯一一个和IO流相结合的集合
 *      可以使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
 *      可以使用Properties集合中的方法load，把硬盘中保存的文件(键值对)，读取到集合中使用
 *
 *   属性列表中每个键及其对应值都是一个字符串
 *   Properties集合是一个双列集合，key和value默认都是字符串
 */
public class DemoProperties {
    public static void main(String[] args) throws IOException {
        //show01();
        show02();
        show03();

    }
    /**
     *    可以使用Properties集合中的方法load，把硬盘中保存的文件(键值对)，读取到集合中使用
     *     void load(InputStream inStream)
     *     void load(Reader reader)
     *     参数：
     *          InputStream inStream:字节输入流，不能读取含有中文的键值对
     *          Reader reader:字符输入流，能读取含有中文的键值对
     *
     *      使用步骤：
     *          1、创建Properties集合对象
     *          2、使用Properties集合对象中的方法load读取保存的键值对的文件
     *          3、遍历Properties集合
     *       注意事项：
     *          1、存储键值对的文件中，键与值默认的连接符合可以使用=，空格(其它符号)
     *          2、存储键值对的文件中，可以使用#进行注释，
     *          3、存储键值对的文件中键与值默认都是字符串，不用在加引号
     *
     */
    private static void show03() throws IOException {
        //1、创建Properties集合对象
        Properties propp = new Properties();
        //  2、使用Properties集合对象中的方法load读取保存的键值对的文件
        propp.load(new FileReader("E:\\daima\\java_day01\\src\\Demo44\\abc"));
        //3、遍历Properties集合
        Set<String> set = propp.stringPropertyNames();
        for (String key : set) {
            String value = propp.getProperty(key);
            System.out.println(key + "=" + value);
        }

    }

    /**
     * 可以使用Properties集合的方法store，把集合中的临时数据，持久化写入到硬盘中存储
     * void store(OutputStream out, String comments)
     * void store(Writer writer, String comments)
     * 参数：
     *      OutputStream out:字节输出流，不能写中文
     *      Writer writer字符输出流，可以写中文
     *      String comments：注释，用来解释说明保存的文件是做什么的，不能使用中文，一班使用空字符串
     * 使用步骤：
     *      1、创建Properties集合对象，添加数据
     *      2、创建字节输入流/字符输出流对象，构造方法中绑定要输出的目的地
     *      3、使用Properties集合的方法store，把集合中的临时数据，持久化写入到硬盘中存储
     *      4、释放资源
     *
     */
    private static void show02() throws IOException {
        //1、创建Properties集合对象，添加数据
        Properties prop = new Properties();
        //使用setProperty往集合里添加数据
        prop.setProperty("张靓颖","168");
        prop.setProperty("迪丽热巴","168");
        prop.setProperty("古力娜扎","168");

        //2、创建字节输入流/字符输出流对象，构造方法中绑定要输出的目的地
        FileWriter fus = new FileWriter("E:\\daima\\java_day01\\src\\Demo44\\abc");

        //3、使用Properties集合的方法store，把集合中的临时数据，持久化写入到硬盘中存储
        prop.store(fus,"save data");

        // 4、释放资源
        fus.close();
    }

    /**
     * 使用Properties集合存储数据，遍历去除Properties集合中的数据
     * Properties集合一个双列集合，key和value默认都是字符串
     *Properties集合是操作字符串的特有方法
     *      Object setProperty(String key, String value)调用Hashtable的方法put
     *      String getProperty(String key)通过key找到value值,此方法相当于Map集合中的get(key)
     *      set<String> stringPropertyNames()返回此属性列表的键集，此方法相当于Map中的keySet方法
     */
    private static void show01() {
        //创建集合对象
        Properties prop = new Properties();
        //使用setProperty往集合里添加数据
        prop.setProperty("张靓颖","168");
        prop.setProperty("迪丽热巴","168");
        prop.setProperty("古力娜扎","168");
        //stringPropertyNames()把键取出，存到一个set集合中
        Set<String> set = prop.stringPropertyNames();

        //变量set集合，
        for (String key : set) {
            String vlaue = prop.getProperty(key);

            System.out.println(key + "->" + vlaue );
        }
    }
}

package Demo45;

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

/**
 * java.io.BufferedInputStream extends InputStream
 * BufferedInputStream:字节缓冲输出流
 *
 * 继承自父类的方法：
 *      int read()从输入流中读取数据的下一个字节。
 *      int read(byte[] b) 从输入流中读取一定数量的字节，并将 其存储在缓冲区数组b中。
 *      void close()关闭输入流，释放资源
 * 构造方法：
 *     BufferedInputStream(InputStream in) 创建一个心得缓冲输入流，以将数据写入指定的底层输入流
 *     BufferedInputStream(InputStream in, int size) 创建一个心得缓冲输入流，以将具有指定缓冲区大小的数据写入指定的底层输入流
 *     参数：
 *        InputStream int：字节输入流，增加一个缓冲区，提高效率
 *        int size：指定缓冲流内部缓冲区的大小
 * 使用步骤：
 *      1、创建FileInputStream对象，构造方法中绑定读取的数据源
 *      2、创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提供效率
 *      3、使用FileInputStream对象中的方法read，读取文件
 *      4、释放资源
 *
 */
public class DemoBufferedInputStream {
    public static void main(String[] args) throws IOException {
        //1、创建FileInputStream对象，构造方法中绑定读取的数据源
        FileInputStream fis = new FileInputStream("E:\\daima\\java_day01\\src\\Demo44\\abc");
        //2、创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提供效率
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3、使用FileInputStream对象中的方法read，读取文件
//        int len = 0;
//        while((len = bis.read())!=-1){
//            System.out.println(len);
//        }

        byte[] bytes = new byte[1024];
        int len =0;
        while((len = bis.read())!=-1){
            System.out.println(len);
        }
        //4、释放资源
        bis.close();
    }
}

package Demo45;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * java.io.BufferedOutputStream extends OutputStream
 * BufferedOutputStream:字节缓冲输出流
 *
 * 继承自父类的共性成员方法
 *     public void close()：关闭此输出流并释放与此流相关的任何资源
 *     public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出
 *     public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
 *     public void write(byte[] b, int off, int len)：从指定的字节数组写入len字节，从偏移量off开始输出到此流
 *     public abstract void write(int b)：将指定的字节输出流
 *
 * 构造方法：
 *      BufferedOutputStream(OutputStream out) 创建一个心得缓冲输出流，以将数据写入指定的底层输出流
 *      BufferedOutputStream(OutputStream out, int size) 创建一个心得缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
 *      参数：
 *          OutputStream out：字节输出流，增加一个缓冲区，提高效率
 *          int size：指定缓冲流内部缓冲区的大小
 * 使用步骤：
 *      1、创建FileOutputStream对象，构造方法中绑定输出的目的地
 *      2、创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提供效率
 *      3、使用FileOutputStream对象中的方法write，把数据写入到内部缓冲区中
 *      4、使用FileOutputStream对象的方法flush把内部缓冲去的数据，刷新到文件中中
 *      5、释放资源
 *
 *
 */

public class DemoBufferedOutputStream {
    public static void main(String[] args) throws IOException {
        //  1、创建FileOutputStream对象，构造方法中绑定输出的目的地
        FileOutputStream file = new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc");
        //2、创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提供效率
        BufferedOutputStream buf = new BufferedOutputStream(file);
        // 3、使用FileOutputStream对象中的方法write，把数据写入到内部缓冲区中
        buf.write("写到内部缓冲区中".getBytes());
       // 4、使用FileOutputStream对象的方法flush把内部缓冲去的数据，刷新到文件中中
        buf.flush();
      //  5、释放资源
        buf.close();
    }
}

package Demo45;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;

/**
 * java.io.BufferedReader extends Reader
 *
 * 继承父类的共性的成员方法
 * int read()读取单个单词并返回
 * int read(char[] cbuf)一次读取多个字符，将字符读入数组
 * void close() 关闭流，释放资源
 *
 * 构造方法:
 *      BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流
 *      BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区缓冲字符输入流
 *      参数：
 *          Reader in:字符输入流，缓冲流给FileReader增加一个缓冲区，提高FileReader的读取效率
 *特有的成员方法：
 *      String readLine() 读取一个文本行
 *                        行的终止符号：\n, \r, (\r\n)
 *             返回值：包含内容的字符串，不包含任何终止符，如果流已经达到末尾，则返回null
 *
 * 使用步骤：
 *      1、创建字符缓冲输入流对象，构造方法中传递字符输入流
 *      2、使用字符缓冲输入流对象中的方法read/readLine读取文本
 *      3、释放资源
 *
 */
public class DemoBufferedReader {
    public static void main(String[] args) throws IOException {
        //  1、创建字符缓冲输入流对象，构造方法中传递字符输入流
        BufferedReader brs = new BufferedReader(new FileReader("E:\\daima\\java_day01\\src\\Demo44\\abc"));
        String len ;
        while ((len = brs.readLine()) != null){
            System.out.println(len);
        }

        brs.close();
    }
}

package Demo45;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * java.io.BufferedWriter extends Writer
 * BufferedWriter字符缓冲输出流
 * 继承父尅的共性方法;
 *     void write(int c)写入单个字符
 *     void write(char[] cbuf)写入字符数组
 *     abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分，off数组的开始索引，len写的字符个数
 *     void write(String str)写入字符串
 *     void write(String str, int off, int len)写入字符串的某一部分，off字符串的开始索引，len写的字符串的个数
 *     void flush()刷新该流的缓冲
 *     void close()关闭此流，但要先刷新它
 *
 * 构造方法：
 *      BufferWriter(writer out)创建一个使用默认大小输出缓冲区字符输出流
 *      BufferWriter(writer out, int sz)创建一个使用给定大小输出缓冲区的新缓冲自负输出流
 *      参数：
 *          Writer out：字符输出流，缓冲流给FileWriter增加一个缓冲区，提高FileWriter的写入效率
 *          int sz：指定缓冲区的大小，不写就是默认大小
 * 特有的成员方法：
 *      void newline写入一个行分隔符，会根据不同的操作系统，获取不同的行分隔符
 *
 * 使用步骤：
 *      1、创建一个字符缓冲输出流对象，构造方法中传递字符输出流
 *      2、调用字符缓冲输出流中的方法Writer，把数据自而入内存缓冲区中
 *      3、调用字符缓冲输出流中的方法flush，把内存缓冲区中的数据，刷新到文件中
 *      4、释放资源
 */
public class DemoBufferWriter {
    public static void main(String[] args) throws IOException {
        //1、创建一个字符缓冲输出流对象，构造方法中传递字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\daima\\java_day01\\src\\Demo44\\abc"));
        //2、调用字符缓冲输出流中的方法Writer，把数据自而入内存缓冲区中
        for (int i = 0; i < 10; i++) {
            bw.write("我爱你");
            bw.newLine();

        }
        bw.close();

    }
}