Java 处理流

处理流：

处理流类型：

作用:增强功能、提供性能，节点流之上
1.缓冲流
输入流:BufferedInputStream（字节） BufferedReader（字符）

输出流:BufferedOutputStream（字节） BufferedWriter（字符）

2、转换流: 字节流 转为字符流   处理乱码(编码集、解码集)
1）、编码与解码概念
 编码： 字符  ---编码字符集>二进制
 解码:二进制  --解码字符集->      字符
2）、乱码:
（1）编码与解码的字符集不统一
（2）字节缺少，长度丢失
（3）文件乱码 
InputStreamReader(字节输入流,"解码集")
OutputStreamWriter(字符输出流,"编码集")

一、缓冲流

【1】对I/O进行缓冲是一种常见的性能优化，缓冲流为I/O流增加了内存缓冲区，增加缓冲区的两个目的： 
（1）允许Java的I/O一次不只操作一个字符，这样提高䇖整个系统的性能； 
（2）由于有缓冲区，使得在流上执行skip、mark和reset方法都成为可能。

【2】缓冲流：它是要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能， 
提高了读写的效率，同时增加了一些新的方法。例如：BufferedReader中的readLine方法， 
BufferedWriter中的newLine方法。

1.字节缓冲流

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
 * 字节流文件拷贝+缓冲流 ，提高性能
 * 缓冲流(节点流)
 * @author Administrator
 *
 */
public class BufferedByteDemo {
  
       /**
        * @param args
        */
       public static void main(String[] args) {
              
       }
       /**
        * 文件的拷贝
        * @param  源文件路径
        * @param  目录文件路径
        * @throws FileNotFoundException,IOException
        * @return 
        */
              public static void copyFile(String srcPath,String destPath)
               throws FileNotFoundException,IOException {
                     //1、建立联系 源(存在且为文件) +目的地(文件可以不存在)  
                     File src =new File(srcPath);
                     File dest =new File(destPath);
                     if(! src.isFile()){ //不是文件或者为null
                            System.out.println("只能拷贝文件");
                            throw new IOException("只能拷贝文件");
                     }
                     //2、选择流
                    //格式如下：
                     InputStream is =new BufferedInputStream(new 
                     FileInputStream(src));
                     OutputStream os =new BufferedOutputStream( 
                     new FileOutputStream(dest));
                     //3、文件拷贝   循环+读取+写出
                     byte[] flush =new byte[1024];
                     int len =0;
                     //读取
                     while(-1!=(len=is.read(flush))){
                            //写出
                            os.write(flush, 0, len);
                     }
                     os.flush(); //强制刷出
                     
                     //关闭流
                     os.close();
                     is.close();
              }
  
}

小结：

用法就是将FileInputStream和FileOutputStream给包装起来

 

2.字符缓冲流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 字符缓冲流 +新增方法(不能发生多态)
 * @author Administrator
 *
 */
public class BufferedCharDemo {
 
       /**
        * @param args
        */
       public static void main(String[] args) {
              //创建源 仅限于 字符的纯文本
              File src =new File("E:/xp/test/Demo03.java");
              File dest =new File("e:/xp/test/char.txt");
              //选择流
              BufferedReader reader =null;           
              BufferedWriter wr =null;
              try {
                     reader =new BufferedReader(new FileReader(src));
                     wr =new BufferedWriter(new FileWriter(dest));
                     //读取操作
                     /*
                     char[] flush =new char[1024];
                     int len =0;
                     while(-1!=(len=reader.read(flush))){
                            wr.write(flush, 0, len);
                     }*/
                     //新增方法的操作
                     String line =null;
                     while(null!=(line=reader.readLine())){
                            wr.write(line);
                     //wr.append("\r\n");
                            wr.newLine(); //换行符号
                     }
                     wr.flush();//强制刷出
              } catch (FileNotFoundException e) {
                     e.printStackTrace();
                     System.out.println("源文件不存在");
              } catch (IOException e) {
                     e.printStackTrace();
                     System.out.println("文件读取失败");
              }finally{
                     try {
                            if (null != wr) {
                                   wr.close();
                            }
                     } catch (Exception e2) {
                     }
                     try {
                            if (null != reader) {
                                   reader.close();
                            }
                     } catch (Exception e2) {
                     }
              }
       }
 
}

小结：

用法与字节缓冲流基本一致，新增.readLine()，.newLine()方法

 

 

二、转换流

• 转换流有两种： 
  （1）InputStreamReader：将字节流转换为字符流; 
  （2）OutputStreamWriter：将字符流转换为字节流。

 输出流：

public OutputStreamWriter(OutputStream out, String charsetName)

输入流：

public InputStreamReader(InputStream in, String charsetName)

他们分别传递的参数是OutputStream和InputStream，以及他们的子类（多态）

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
  
/**
 * 转换流: 字节转为字符
 * 1、输出流 OutputStreamWriter 编码
 * 2、输入流 InputStreamReader  解码
 * 
 * 确保源不能为乱码
 * @author Administrator
 *
 */
public class ConverDemo02 {
  
       /**
        * @param args
        * @throws IOException 
        */
       public static void main(String[] args) throws IOException {
              //指定解码字符集
              BufferedReader br =new BufferedReader(
                            new InputStreamReader(
                                   new 
                                   BufferedInputStream(
                                                 
                                  new FileInputStream( 
                                                               new File("E:/xp/test/Demo03.java"))),"UTF-8")
                            );
              //写出文件 编码
              BufferedWriter bw =new BufferedWriter(
                            new OutputStreamWriter(
                                   new BufferedOutputStream(     
                                   new FileOutputStream(new 
                                   File("E:/xp/test/encode.java"
                                   )))));
                            
              String info =null;
              while(null!=(info=br.readLine())){
                     //System.out.println(info);
                     bw.write(info);
                     bw.newLine();
              }
              bw.flush();
              bw.close();
              br.close();
       }
  
}