java中OutputStream字节流与字符流InputStreamReader 每一种基本IO流BufferedOutputStream，FileInputStream，FileOutputStream，BufferedInputStream，BufferedReader，BufferedWriter，FileInputStream，FileReader，FileWriter，InputStr

 

BufferedOutputStream，FileInputStream，FileOutputStream，BufferedInputStream，BufferedReader，BufferedWriter，FileInputStream，FileReader，FileWriter，InputStreamReader
每一种流都介绍到了，详细一目了然的详细

 

下面是字节流常见操作的四种方式：

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.BufferedInputStream;
import java.io.IOException;

/*
 * 四种方式实现大文件数据的读取写入--->复制
 * 1.基本字节流一次读取一个字节
 * 2.基本字节流一次读取一个字节数组
 * 3.高效字节流一次读取一个字节
 * 4.高校字节流一次读取一个字节数组
 * 
 */
public class Test2 {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();

        // method1("E:\\b.txt", "c.txt");    //基本字节流一次一个字节
        // method2("E:\\b.txt", "c.txt");    //一次一个字节数组
        // method3("E:\\b.txt", "c.txt");    //高效字节流一次一个字节
        method4("E:\\b.txt", "c.txt");       //高效字节流一次一个字节数组

        long end = System.currentTimeMillis();
        System.out.println("共耗时： " + (end - start) + "毫秒");
    }

    // 1.基本方法字节流一次读取一个字节
    public static void method1(String srcPath, String destPath)
            throws IOException {
        // 读取数据对象
        FileInputStream fis = new FileInputStream(srcPath);
        // 写入数据目标文件路径
        FileOutputStream fos = new FileOutputStream(destPath);
        // 数据读写
        // 直接以单字节读取
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        // 关闭流
        fos.close();
        fis.close();
    }

    // 2.基本字节读取一次读取一个数组
    public static void method2(String srcPath, String destPath)
            throws IOException {
        // 数据读取的对象封装
        FileInputStream fis = new FileInputStream(srcPath);
        // 数据写入对象封装
        FileOutputStream fos = new FileOutputStream(destPath);
        // 数据的读写
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        // 关闭流
        fis.close();
        fos.close();
    }

    // 3.高效字节流一次读取一个字节
    public static void method3(String srcPath, String destPath)
            throws IOException {
        // 数据读取对象封装
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcPath));
        // 数据写入对象封装
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destPath));

        // 数据读写操作
        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }

        // 关闭流
        bos.close();
        bis.close();
    }

    // 4.高效字节流读取一个字节数组
    public static void method4(String srcPath, String destPath)
            throws IOException {
        // 数据读取对象封装
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcPath));
        // 数据写入对象
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destPath));

        // 数据读写操作
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        // 关闭流
        bos.close();
        bis.close();
    }
}

 

下面是字符流常见操作的四种方式：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * 需求：复制文本文件
 *     分析：如果使用Windows记事本打开之后能读懂就是用字符流，显然此处使用字符流
 *     字符流有五种方式:尤其是第五种字符高效流的特殊方式
 *     数据源的地址以及目标地址也应该用String封装
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 字符流读取源文件对象
        // method1(); // 普通方法的单字节读取
        // method2(); //普通的字符数组
　　　　　　　//method3();  //高效的字节数组

        method4();   //高效的字节数组
        method5();    //按行读取写入  ，这个很常用！！
    }

    private static void method1() throws IOException {
        // 源文件对象，读取数据
        // InputStreamReader isr = new InputStreamReader(new FileInputStream(
        // "c:\\a.txt"));
        FileReader fr = new FileReader("c:\\a.txt");
        // 目标文件对象，写入数据
        FileWriter fw = new FileWriter("dest.txt");

        // 数据的复制
        int ch = 0;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
        }

        // 释放资源
        fr.close();
        fw.close();
    }

    // 字符数组读取复制文件
    private static void method2() throws IOException {
        // 数据源文件对象，读取数据
        FileReader fr = new FileReader("c:\\a.txt");
        // 目标文件对象，写入数据
        FileWriter fw = new FileWriter("dest.txt");

        // 数据复制
        char[] chs = new char[1024];
        int len = 0;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
            fw.flush(); // 字符流在写入数据时一定记得刷新！
        }

        // 释放资源
        fr.close();
        fw.close();
    }

    // 高效字符数组复制文件--->单字符模式
    public static void method3() throws IOException {
        // 数据源文件对象，读取数据
        BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
        // 目标文件对象，写入数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("dest1"));

        // 文件的复制
        int ch = 0;
        while ((ch = br.read()) != -1) {
            bw.write(ch);
        }

        // 释放资源
        bw.close();
        br.close();
    }

    // 高效字符数组复制文本文件--->字符数组模式
    private static void method4() throws IOException {
        // 数据源文件对象，读取数据
        BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
        // 目标文件对象，写入数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("dest1.txt"));

        // 数据复制
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1) {
            bw.write(chs);
            bw.flush();
        }

        // 释放资源
        br.close();
        bw.close();
    }

    // 高效字符流的特殊方法--->按行读取写入~！这个是狠狠常用的
    private static void method5() throws IOException {
        // 数据源文件对象，读取数据
        BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
        // 目标文件对象，写入数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("dest.txt"));

        // 数据复制操作
        String line = null;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        // 释放资源
        br.close();
        bw.close();
    }
}