java I/O流（一）——FileWriter，BufferedWriter，inputStream,BufferedInputStream,InputStreamReader

I/O全名：Input Output，输入输出的意思

•IO流用来处理设备之间的数据传输
•流操作分两种：字节流，字符流
•流按流向分为：输入流，输出流

•字节流的抽象积累

◦InputStream
◦OutputStream

•字符流的抽象基类

◦Reader
◦Writer

FileWriter

•需求：在硬盘上创建一个文件，并且写入数据
那我们怎么去做？他构造函数比较多的，我们看例子

public class HelloJJAVA {
    public static void main(String[] args) {
        /** * 需求：在硬盘上创建一个文件，并且写入数据 */

        // 一被初始化就必须要有被操作的文件
        // 如果不指定位置，就创建在同目录下
        // 如果目录下存在同名文件，覆盖
        try {
            FileWriter fileWriter = new FileWriter("test.txt");
            // 写入数据到内存
            fileWriter.write("abcde");
            // 刷新该流的缓冲
            // fileWriter.flush();

            // 关闭流 关闭之前会刷新，和flush的区别在于flush刷新后流可以继续工作
            fileWriter.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

这样在我们的项目根目录下就可以看到生成的文件了

文件续写
我们知道，文件存在的话就会覆盖，但是我们不想这样，我们想在原有的数据中续写，这该去怎么做？

public class HelloJJAVA {
    public static void main(String[] args) {

        try {
            //参数2代表不覆盖已有的文件，支持续写
            FileWriter fileWriter = new FileWriter("demo.txt",true);
            fileWriter.write("你好");
            fileWriter.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

构造传参的时候设置为true就可以续写文件了

FileReader
既然写已经会了，那我们就来读取了

public class HelloJJAVA {
    public static void main(String[] args) {
        try {
            // 创建一个文件读取流对象，和指定名称的文件关联，保证文件存在，
            // 如果不存在,异常
            FileReader fileReader = new FileReader("demo.txt");
            // 读取单个字符,自动往下读
            int cd = fileReader.read();
            System.out.println((char) cd);

            //全部打印
            int ch = 0;
            while ((ch = fileReader.read()) != -1) {
                System.out.println(ch);
            }

            fileReader.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

这样就可以按照字节读取了，我们也可以把读到的字符存储在数组中

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class HelloJJAVA {
    public static void main(String[] args) {

        try {
            FileReader fileReader = new FileReader("demo.txt");
            char[] buf = new char[3];

            int num = fileReader.read(buf);

            System.out.println("num:" + num + new String(buf));

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

文本复制
读写都说了，我们来看下其他的操作，我们首先来看复制

•复制原理：其实就是将C盘下的文件数据存储到D盘的一个文件中
实现的步骤：
1.在D盘创建一个文件，用于存储文件中的数据
2.定义读取流和文件关联
3.通过不断的读写完成数据的存储
关闭资源

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class HelloJJAVA {
    public static void main(String[] args) {

        copy_1();
        copy_2();
    }

    // 从c盘读一个字符，就往D盘写一个字符
    public static void copy_1() {
        try {
            // 创建目的地
            FileWriter fw = new FileWriter("copy_1.txt");
            // 与已有文件关联
            FileReader fr = new FileReader("copy_1.txt");
            int ch = 0;
            while ((ch = fr.read()) != -1) {
                // 读一个 写一个
                fw.write(ch);
            }
            fw.close();
            fr.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void copy_2() {
        FileWriter fw = null;
        FileReader fr = null;

        try {
            fw = new FileWriter("copy_2.txt");
            fr = new FileReader("copy_2.txt");

            char[] buf = new char[1024];

            int len = 0;
            while ((len = fr.read(buf)) != -1) {
                fw.write(buf, 0, len);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }}

这里做了两种方式的拷贝方式，其实都是整理好思路，读和写的一个过程罢了！

字符流的缓冲区，提高了对数据的读写效率，他有两个子类
•BufferedWriter
•BufferedReader

我们还是复制文件这个问题，现在我们有缓冲区，我们要怎么样复制文件？

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class HelloJJAVA {
    public static void main(String[] args) {
        /** * 缓冲区文件复制 */
        BufferedReader bufr = null;
        BufferedWriter bufw = null;

        try {
            bufr = new BufferedReader(new FileReader("buffer.txt"));
            bufw = new BufferedWriter(new FileWriter("buffercopy.txt"));

            String line = null;

            while((line = bufr.readLine()) != null){
                bufw.write(line);
            }

            //关闭流
            bufr.close();
            bufw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

字节流读取操作
字符流我们讲的差不多了，我们接着说字节，其实他们类似的，知识他操作的是字节而已

•inputStream:读
•outputStream:写
我们还是从例子开始

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class HelloJJAVA {
    public static void main(String[] args) {
        writeFile();

    }

    // 写文件
    public static void writeFile() {
        try {
            FileOutputStream fo = new FileOutputStream("demo.txt");
            fo.write("test".getBytes());
            fo.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

专门处理的字节流

public static void readFile2() {
        try {
            FileInputStream fs = new FileInputStream("demo.txt");
            int num = fs.available();
            System.out.println(num);
            fs.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

我们发现直接用available就可以拿到字节了，原理其实是这段代码

public static void readFile2() {
        try {
            FileInputStream fs = new FileInputStream("demo.txt");
            byte[] buf = new byte[fs.available()];
            fs.read(buf);
            System.out.println(new String(buf));
            fs.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

字节流的缓冲区

这个，和我们的字符流基本上没有什么差别，我们来拷贝mp3，看例子

// 通过字节流的缓冲区拷贝图片
    public static void copyMp3() {

        try {
            FileInputStream fi = new FileInputStream("audio.mp3");
            BufferedInputStream buf = new BufferedInputStream(fi);

            FileOutputStream fio = new FileOutputStream("audioCapy.mp3");
            BufferedOutputStream buo = new BufferedOutputStream(fio);

            int ch = 0;

            while ((ch = buf.read()) != -1) {
                buo.write(ch);
            }

            buf.close();
            buo.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
//这样，就直接拷贝了

转换流InputStreamReader

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class HelloJJAVA {
    public static void main(String[] args) throws IOException {
        //获取键盘录入对象
        InputStream in = System.in;
        //转换
        InputStreamReader isr = new InputStreamReader(in);
        //提高效率
        BufferedReader bur = new BufferedReader(isr);
        String line = null;
        while((line = bur.readLine()) != null){
            if(line.equals("over"))
                break;
            System.out.println(line.toString());
        }
    }
}

写入转换流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class HelloJJAVA {
    public static void main(String[] args) throws IOException {
        //获取键盘录入对象
        InputStream in = System.in;
        //转换
        InputStreamReader isr = new InputStreamReader(in);
        //提高效率
        BufferedReader bur = new BufferedReader(isr);

        OutputStream os = System.out;
        OutputStreamWriter osw = new OutputStreamWriter(os);
        BufferedWriter bufw = new BufferedWriter(osw);


        String line = null;
        while((line = bur.readLine()) != null){
            if(line.equals("over"))
                break;
            bufw.write(line.toString());
            bufw.newLine();
            bufw.flush();
        }
    }
}

如何选择流？
◦1.明确源和目的

■源：输入流 InputStream Reader
■目的：输出流 OutputStream writer
◦2.明确操作的数据是否是纯文本

■是：字符流
■不是：字节流