IO流简单应用

1.IO流的回顾
    按流向区分：
        输入流    InPutStream  FileInPutStream    Reader    
        输出流    OutPutStream FileOutPutStream    Writer    

    按读取类型区分
        字节流    InPutStream  OutPutStream
        字符流    Reader        Writer

2.引入了小数组的形式来解决读写效率低的问题
        byte[] arr = new byte[1024*8];    
        
        

3. 高效缓冲输入流，和输出流
        缓冲输入流    BufferedInPutStream
        缓冲输出流    BufferedOutPutStream

        public class Test55 {
            public static void main(String[] args) throws  IOException {
                BufferedInputStream  bis =  new BufferedInputStream(new FileInputStream("aa.mp4"));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bb.mp4"));
                int b;
                while((b= bis.read()) !=-1){
                    bos.write(b);
                }
                bis.close();
                bos.close();
            }
        }
            
        
4. 刷新flush、 和close方法的区别。

    当我们写出的时候，担心有字节没有写出完全，可以用刷新的方法。

        一般我们关闭流通道的时候，用close()方法。
        底层他会每次先刷新流通道，调用flush()方法。

5. 字节流读写中文的问题。

        中文是字符。一个字符占两个字节的位置。

        所以按照字节去读取的时候，有可能读取到半个中文。
        那么就会造成乱码！！
    
        写出的时候，也是按照字节来写出的时候，也有可能把相邻的两个
        字节拼接出问题，导致，和我们预期输出的中文错乱。
        
        
        public class Test6 {
            public static void main(String[] args) throws IOException {
        //        input();    //测试读取中文，可能出现乱码问题。
                output();    //测试写出中文，可能会出现的乱码问题。
            }
            
            private static void output() throws IOException {
                // TODO 这里还有没完成的功能，需要测试输出流，写出中文乱码问题。
                FileOutputStream fos = new FileOutputStream("abc.txt");
                //将字符串，转化为字节数组来输出。
                fos.write("我读书少，你不要骗我！".getBytes());  
                fos.close();
            }

            //测试读取中文，可能出现乱码问题。
            public static void input() throws IOException{
                FileInputStream fis =  new FileInputStream("a.txt");
                byte[] arr = new byte[3];
                
                int len;        //读取到的字节，转化为int类型数据。
                while(( len = fis.read(arr)) != -1){
                    //自己读取，都是半个半个字符读取，可能会造成乱码原因。
                    System.out.println(new String(arr,0,len));  
                }
                fis.close();
            }
        }

        
        
        
6.字符流        Reader  Writer
        
        FileReader
        FileWriter
        
        （1）什么时候用字节流，什么时候用字符流。
            用字节流
                用来拷贝文件的时候用字节流。
            
            用字符流        
                用来把文件中的 文本内容，读取到内存中用的时候用字符流。
                或者把程序中的字符串，写出到文件中的时候，用字符流。
            
        （2）字符流能用来拷贝非文本文件吗 ？
                不可以。
            
7. 综合练习： 读取文本，替换字符串。写出到另一个文本。

    需求：将 a.txt中的一下文本，读取之后，进行替换
            你好，我的名字是{name},
            我是一只{type},
            我的主人是{master}。
        替换之后
            你好，我的名字是{哮天犬},
            我是一只{狗},
            我的主人是{二郎神}。
        最终，把替换后的字符串，写入 b.txt文件中。
            
    具体代码：
        public class Test7 {
            public static void main(String[] args) throws IOException {
                FileReader fr = new FileReader("b.txt"); // 字符读取流对象创建
                StringBuffer sb = new StringBuffer(); // 创建一个字符串缓冲对象。
                char[] arr = new char[1024]; // 定义一个字符数组，
                int len; // 返回读取到的数组长度。
                while ((len = fr.read(arr)) != -1) {
                    sb.append(arr); // 把数组中的字符，拼接到字符串对象中。
                }
                // 替换读取到的文本的内容。
                String info = sb.toString().replace("name", "哮天犬");
                String info2 = info.replace("type", "狗");
                String newinfo = info2.replace("master", "二郎神");
                // 创建文件输出流对象，然后写出字符串内容。
                FileWriter fw = new FileWriter("bbb.txt");
                fw.write(newinfo);
                fr.close(); // 关闭流通道
                fw.close();// 关闭流通道。
                System.out.println("写出完成");
            }
        }

8.     高效缓冲字符输入流，和高效缓冲字符输出流
        BufferedReader 
        BufferedWriter

        /**
         * 
         * 高效缓冲字符输入流 高效缓冲字符输出流。
         */
        public class Test8 {
            public static void main(String[] args) throws IOException {
                BufferedReader br = new BufferedReader(new FileReader("a.txt")); // 创建高效读取流。
                BufferedWriter bw = new BufferedWriter(new FileWriter("bbbb.txt")); // 创建高效输出流。

                int b; // 读取到的字符数。
                while ((b = br.read()) != -1) { // 循环读取 缓冲字符数组序列。
                    bw.write(b); // 把内存缓冲区的字符数组，输出。
                }
                // 关闭输入和输出流通道。
                br.close();
                bw.close();
                System.out.println("拷贝完毕！");
            }
        }

9. 通过io流给文件加密解密
        /**
         *  通过io流操作，图片加密。
         *  //加密，是输出的时候，亦或 ^ 一个数。
         *  
         *  解密的时候，把加密过的文件。再次亦或同一个 密钥数。
         *  那么就解密出来了。
         */
        public class Test9 {
            public static void main(String[] args) throws IOException {
                FileInputStream fis = new FileInputStream("a.jpeg");
                FileOutputStream fos = new FileOutputStream("aa.jpeg");
                
                int b;
                while((b=fis.read()) !=-1){
                    fos.write(b ^ 123);   //加密，是输出的时候，亦或 ^ 一个数。
                }
                fis.close();
                fos.close();
            }
        }