IO处理流

IO中的处理流，相当于给原来的字节流或者字符流套上一个套子，用于增强功能、提供性能。

缓冲流

1、字节缓冲流
BufferedInputStream
BufferedOutputStream
2、字符缓冲流
BufferedReader 比字节流字符流新增String readLine() 读取一个文本行
BuffeedWriter 比字节流字符流新增void newLine() 写入一个行分隔符

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;
/**
 * 字节流文件拷贝 + 缓冲流，提高性能
 * 缓冲流（节点流）
 * 程序为桥梁
    a.建立联系：File对象   源头和目的地
    b.选择流：文件输入流 InputStream FileInputStream
            文件输出流   OutputStream  FileOutputStream 
    c.操作：拷贝
            byte[] flush = new byte[1024];
            int len = 0;
            while(-1 != (len = 输入流.read(flush))){
                输出流.write(flush,0,len)
            }
            输出流.flush
    d.释放资源：关闭两个流
 */
public class CopyFileByByte {
    public static void main(String[] args) {
        String srcPath = "G:/java/test/background.jpg";
        String desPath = "G:/java/test/100.jpg";
        try {
            copyFile(srcPath,desPath);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件没有找到");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件拷贝失败或者关闭流失败");
        }
    }
    /**
     * 文件的拷贝，传入File参数
     * @param src
     * @param des
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static void copyFile(File src,File des) throws FileNotFoundException,IOException {
        //1.建立联系    源头(存在且为文件) + 目的地(文件可以不存在)
        if(!src.isFile()){
            throw new IOException("只能拷贝文件");
        }
        //des为存在的文件夹，不能建立与文件夹同名的文件
        if(des.isDirectory()){
            System.out.println(des.getAbsolutePath() + "不能建立与文件夹同名的文件");
            throw new IOException(des.getAbsolutePath() + "不能建立与文件夹同名的文件");
        }
        //2.选择流，用缓冲流进行包装，提高性能
        InputStream is = new BufferedInputStream(new FileInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(des));
        //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();
    }
    /**
     * 文件的拷贝，传入String参数，路径
     * @param srcPath
     * @param desPath
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static void copyFile(String srcPath,String desPath) throws FileNotFoundException,IOException {
        copyFile(new File(srcPath),new File(desPath));
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
/**
 * 纯文本文件的拷贝
 * 字符缓冲流 + 新增方法（不能发生多态）读取一行和回车换行
 */
public class CopyFileByChar {
    public static void main(String[] args) {
        File src = new File("G:/java/test/path.java");
        File des = new File("G:/java/test/Path1.java");

        BufferedReader charStreamR = null;
        BufferedWriter charStreamW = null;
        try {
            //用缓冲流包装，提高性能
            charStreamR = new BufferedReader(new FileReader(src));
            charStreamW = new BufferedWriter(new FileWriter(des));
            /*
            char[] flush = new char[2];
            int len = 0;
            while(-1 != (len=charStreamR.read(flush))){
                charStreamW.write(flush, 0, len);
            }
            */
            //新增方法的操作
            String line = null;
            while(null != (line=charStreamR.readLine())){//读取一行
                charStreamW.write(line);
//              charStreamW.append("\r\n");
                charStreamW.newLine();//回车换行，\r\n
            }
            charStreamW.flush();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件夹或不可创建或不可打开");
        } finally {
            try {
                charStreamW.close();
                charStreamR.close();
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("关闭流失败");
            }
        }
    }
}

转换流：字节流转为字符流，处理乱码（编码集、解码集）

1、编码与解码概念，以程序为中心
编码：字符 –编码字符集-> 二进制
解码：二进制 –解码字符集-> 字符
2、乱码
     1)、编码与解码的字符集不统一
     2)、字节缺少，长度丢失
3、文件乱码

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;
import java.io.UnsupportedEncodingException;
/**
 * 转换流
 */
public class Charset {
    public static void main(String[] args) throws IOException {
        test1();
        test2();
        test3();
    }
    /**
     * 编码与解码字符集必须统一，否则乱码
     * @throws UnsupportedEncodingException
     */
    public static void test1() throws UnsupportedEncodingException{
        System.out.println("-------编码与解码字符集必须统一，否则乱码-------------------");
        //解码byte-->>char
        String str = "中国";//当前默认字符集gbk
        //编码char-->>byte
        byte[] data = str.getBytes();
        //使用平台的默认字符集解码指定的 byte数组，构造一个新的 String
        System.out.println(new String(data));//编码与解码字符集统一，返回"中国"

        data = str.getBytes("utf-8");//设定编码字符集
        System.out.println(new String(data));//编码为utf-8，解码为gbk，字符集不统一出现乱码，返回"涓浗"

        //编码
        byte[] data2 = "中国".getBytes("utf-8");
        //解码
        str = new String(data2,"utf-8");
        System.out.println(str);
    }
    /**
     * 字节数不完整，出现乱码
     */
    public static void test2(){
        System.out.println("----------字节数不完整，出现乱码--------------------");
        String str = "中国";
        byte[] data = str.getBytes();
        System.out.println("\"中国\"这两个字的字节长度：" + data.length);
        System.out.println("字节长度减1后的字符：" + new String(data,0,data.length -1));
    }
    /**
     * 转换流：字节流转为字符流(确保源不为乱码)
     * 1、输出流：OutputStreamWriter 编码
     * 2、输入流：InputStreamReader  解码
     * @throws IOException 
     */
    public static void test3() throws IOException{
        System.out.println("--------转换流：字节流转为字符流(确保源不为乱码)-------------------");
        //指定解码字符集，path.java编码为utf-8
        BufferedReader br = new BufferedReader(
            new InputStreamReader(
                new FileInputStream(new File("G:/java/test/path.java")),"utf-8")//没有乱码
                //new FileInputStream(new File("G:/java/test/path.java")))//默认gbk，出现乱码
        );
        //写出文件，按字符集编码，不会出现乱码
        BufferedWriter bw = new BufferedWriter(
            new OutputStreamWriter(
                new FileOutputStream(new File("G:/java/test/encode.txt")),"utf-8")
                //new FileOutputStream(new File("G:/java/test/encode.txt")))//ANSI字符集，不会出现乱码
        );
        String info = null;
        while(null != (info=br.readLine())){//解码
            System.out.println(info);
            bw.write(info);
            bw.newLine();
        }
        bw.flush();
        bw.close();
        br.close();
    }
}