处理流

1.缓冲流(重点)：BufferedReader,BufferedWriter,BufferedInputStream,BufferedOutputStream

(1).作用：提高流读取和写入的速度,提高读写速度的原因：内部提供了一个缓冲区

(2).两个实例：

缓冲字符流(文本)文件输入输出

/*
     * 使用BufferedReader和BufferedWriter实现文本文件复制
     */
    public void testBufferedReaderWriter() 
    {
        //创建文件和相应的流
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hi.txt")));
            
            //读写操作
            char[] cbuf = new char[1024];
            int len;
            while ((len = br.read(cbuf)) != -1)
            {
                bw.write(cbuf,0,len);
                bw.flush();//刷新情况缓冲区的内容
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            //关闭资源
            if (br != null)
                try {
                    br.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            if (bw != null)
                try {
                    bw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }

 

 

缓冲字节流的(非文本)文件输入输出

//实现非文本文件的复制
    public static void BufferedStreamTest() 
    {
        //2.2造缓冲流 
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件 
            File srcFile = new File("1.jpg");
            File desFile = new File("2.jpg");
            
            //2.造流
            //2.1.造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(desFile);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            
            //3.复制的细节：读取,写入
            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer)) != -1)
            {
                bos.write(buffer,0,len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            //4.资源的关闭
            //要求：先关闭外层的流，再关闭内层的流
            //说明：系统在我们关闭外层流后，会帮我们自动关闭内层流(所以只需关闭外层流)
            if (bis != null)
            {
                try {
                    bis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (bos != null)
            {
                try {
                    bos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

 

2.转换流(重点)：

* (1).属于字符流
* InputStreamReader：将字节输入流转为字符输入流
* OutputStreamReader：将字符输出流转为字节输出流
* 所以整个过程就是将字节流先封装成字符流进行传输，最后再将其转回字节流的过程
* (2).作用：提供字节流与字符流之间的转换(整个过程:字节流->字符流->字符流->字节流)
*
* (3).解码过程：字节数组-->字符数组 ，字符串
*       编码过程：字符数组，字符串-->字节数组
*
常见的字符集补充
* ASCII:美国标准信息交换表
* ISO8859-1:拉丁表码，欧洲码表
* GB2312：中文编码表，最多两个字节编码表示所有字符
* GBK:国际标准编码表，融合了更多中文符号，最多两字节编码
* Unicode:国际标准码，融合目前所有使用的字符，为每个字符分配唯一的一个字符码
* UTF-8：变长的编码方式，可用1-4个字节来表示1个字符

应用：

//综合使用InputStreamReader和OutputStreamWriter
    public static void test2() 
    {
        InputStreamReader isr = null;
        OutputStreamWriter osr = null;
        try {
            File file1 = new File("hello.txt");
            File file2 = new File("hi.txt");
            
            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);
            
            isr = new InputStreamReader(fis);
            osr = new OutputStreamWriter(fos);
            
            char[] cbuf = new char[5];
            int len;
            while ((len = isr.read(cbuf)) != 0)
            {
                osr.write(cbuf,0,len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (isr != null)
                try {
                    isr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            if (osr != null)
                try {
                    osr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
    }

 

 

3.标准输入输出流：(1).System.in:默认从键盘中读入   System.out:默认从显示屏上读出

　　　　　　　　   (2).System类的setIn(InputStream is) / setOut(PrintStream ps)方式,即将原本再键盘和显示屏输入输出的转移到is 和 ps流中进行输入和输出

　　　　　　　　   (3).System.In其具体实现是通过转换流InputStreamReader为中间方式，在连接到缓冲读入字符流(BufferReader),调用readLine()函数实现

实例：

//从键盘输入字符串，将输入的字符串转为大写，如果输入的字符串为e,exit时，退出程序
    //法一：Scanner实现,调用next()返回字符串    
    //法二：System.in实现，System.in-->转换流-->BufferReader的ReadLine()
    public static void test1() 
    {
        BufferedReader br = null;
        try {
            //System.in是字节流，通过转换流将其转换为字符缓冲流BufferedReader
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);
            
            while (true) 
            {
                //调用readLine()函数读取一行字符串
                String data = br.readLine();
                if (data.equalsIgnoreCase("e") || data.equalsIgnoreCase("exit"))
                {
                    System.out.println("程序结束");
                    break;
                }
                String upperCase = data.toUpperCase();
                System.out.println(upperCase);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (br != null)
                try {
                    br.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
    }

 

4.数据流：(1).DataInputStream和DataOutputStream

　　　　   (2).作用：用于读取或写出基本数据类型或变量 

//DataOutputStream(将文本类型和字符串输入到文件中)
    public void test3()
    {
        DataOutputStream dos = null;
        try {
            dos = new DataOutputStream(new FileOutputStream("hello.txt"));
            dos.writeUTF("张三");
            dos.flush();
            dos.writeInt(20);
            dos.flush();
            dos.writeBoolean(true);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (dos != null)
                try {
                    dos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
    }

 

5.打印流：(1).PrintStream和PrintWriter   (2).用于将本来打印在控制台上的内容打印到对应的打印流中的文件去

　　　　　 (3).关键句:System.setOut(ps);将本应在控制台输出的内容转移到ps打印输出流中的文件去

public static void test2() 
    {
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File("hello.txt"));
            ps = new PrintStream(fos);
            //即将输出的内容从控制台转移到了ps对应的文件中
            if (ps != null) {
                System.setOut(ps);
            }
            
            for (int i = 0; i < 255; i++)
            {
                System.out.print((char)i + " ");
                if (i % 50 == 0)
                {
                    System.out.println();
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (ps != null)
                try {
                    ps.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
    }

 

总结：处理流的总的构建思路：

(1).先建立一个文件:File file = new File("文件路径");

(2).建立一个文件流:FileInputStream fis = new FileInputStream(file);

(3).建立一个处理流:BufferedInputStream bis = new BufferedInputStream(bis);