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

ゝ一纸荒年。 2023-06-13 06:26 10阅读 0赞

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