几种常见数据输入流InpuStream、FileInputStream、BufferedInputStream、InputStreamReader、FileReader，Bufferedreader

InputStream/OutputStream，是所有字节输入/输出流的抽象基类。

1.1

InputStream也是标准输入流，通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源。

PrintStream是标准输出流：

PrintStream ps = System.out;
ps.print("...");//即System.out.print()
ps.println("...");//即System.out.println();

下面是读取单个字符，读取字符串时就不可以了。

InputStream is = System.in;
int by;
while ((by = is.read()) != -1){
    System.out.print((char)by);
}

1.2、当读取String 或 int等类型数据时，可以如下方式：

public static void main(String[] args) {
        /*
        InputStream is = System.in;
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        */
        //下面这行代码等同于上面三行代码
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一个字符串：");
        try {
            String line = br.readLine();
            System.out.println("您输入的字符串是： " + line);
            System.out.println("请输入一个整数： ");

            //以下两行是键盘输入整数并输出到控制台
            int i = Integer.parseInt(br.readLine());
            System.out.println("您输入的整数是： " + i);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

结果：

1.3、由于上述写法太麻烦，Java就提供了一个类实现键盘录入：

Scanner sc = new Scanner(System.in);

Reader(字符输入流的抽象类）其实现子类 ->InputStreamReader （此字符输入流太麻烦，用其子类简化）-> FileReader（升级版字符输入流）;

Writer(字符输出流的抽象类）其实现子类 ->OutputStreamWriter （此字符输出流太麻烦，用其子类简化）-> FileWriter（升级版字符输出流）;

BufferedReader是Reader的直接子类，BufferedWriter是Writer的直接子类

InputStreamReader\OutputStreamWriter、BufferedInputStream/BufferedOutputStream 参数为（FileInputStream(fileName)），

即：

InputStreamReader isr = new InputStreamReader(new FileInputStream(fileName));参数为字节输入流对象

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName));参数为字节输入流对象

InputStreamReade/OutputStreamWriter直接子类为：FileReader/FileWriter，参数为文件名

FileReader fr = new FileReader(fileName),继承自InputStreamReader，可以理解为升级简化版的字符输入流，输出流类同。但是，如果要做字符流的编解码问题，还得使用InputStreamReader/OutputStreamWriter。

BufferedReader br = new BufferedReader(new FileReader(fileName));字符缓冲输入流的参数为字符输入流，输出流类同。

1、FileInputStream/FileOutputStream,代码示例如下：

public class BytesToString {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("a.txt");
            fos = new FileOutputStream("b.txt");
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = fis.read(bytes)) != -1){
//                String str = new String(bytes);
                String str = new String(bytes,0,len);
                System.out.print(str);
                fos.write(bytes,0,len);
//                fos.write(str.getBytes());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2、BufferedInputStream/BufferedOutputStream,代码示例如下：

public class CopyBufferDemo {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
//        method1();
//        method2();
//        method3();
        method4();

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

    // 1：基本字节流一次读写一个字节
    public static void method1(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("a.txt");
            fos = new FileOutputStream("a1.txt");
            int by = 0;
            while ((by = fis.read()) != -1){
                fos.write(by);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            closeRes(fos,fis);
        }
    }

    //2：基本字节流一次读写一个字节数组
    public static void method2(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("a.txt");
            fos = new FileOutputStream("a2.txt");
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            closeRes(fos,fis);
        }
    }
    //3：字节缓冲流一次读写一个字节
    public static void method3(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("a.txt"));
            bos = new BufferedOutputStream(new FileOutputStream("a3.txt"));
            int by = 0;
            while ((by = bis.read()) != -1){
                bos.write(by);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            closeRes(bos, bis);
        }
    }

    //4：字节缓冲流一次读写一个字节数组
    public static void method4(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("a.txt"));
            bos = new BufferedOutputStream(new FileOutputStream("a4.txt"));
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = bis.read(bytes)) != -1){
                bos.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            closeRes(bos,bis);
        }
    }
    //释放资源
    public static  void closeRes(OutputStream bos,InputStream bis){
        if (bos != null && bis != null){
            try {
                bos.close();
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3、InputStreamReader/OutputStreamWriter,代码示例如下：

public class ConversionStreamDemo {
    public static void main(String[] args) {
        try(
                OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"));
                InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
                ) {
            osw.write("唐人盛世一条街");
            osw.flush();
            char[] chars = new char[1024];
            int len = 0;
            while ((len = isr.read(chars)) != -1){
                System.out.println(new String(chars,0,len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4、FileReader/FileWriter,代码示例如下：

public class FileReaderWriter {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("a.txt");
            fw = new FileWriter(("b.txt"));
            char[] chars = new char[1024];
            int len = 0;
            while ((len = fr.read(chars)) != -1){
                fw.write(chars);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fr != null){
                try {
                    fw.close();
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

5、（1）BufferedReader/BufferedWriter，代码示例如下：

public class BufferedStreamCopy {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("a.txt"));
            bw = new BufferedWriter(new FileWriter("aaa.txt"));
            char[] chars = new char[1024];
            int len = 0;
            while ((len = br.read(chars)) != -1){
                bw.write(chars, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null){
                try {
                    bw.close();
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5、（2）BufferedReader/BufferedWriter，

BufferedReader 有三个特殊的方法:public String readLine();以及 void newLine(); void reflush();

关键点代码：

String line = null;
            while ((line = br.readLine()) != null){
                bw.write(line);
                bw.newLine();
                bw.flush();
            }

代码示例如下：

public class BufferedReaderDemo2 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("a.txt"));
            bw = new BufferedWriter(new FileWriter("aa.txt"));
            String line = null;
            while ((line = br.readLine()) != null){
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null){
                try {
                    bw.close();
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5、（3）BufferedReader/BufferedWriter，

案例：点名器——已有文件里存储了班级同学姓名，每一个姓名占一行，要求通过程序实现随机点名。

知识点代码：

1、String line = null;
            while ((line = br.readLine()) != null){
            arr.add(line);

}

2、Random r = new Random();
        int index = r.nextInt(arr.size());

整体代码示例如下：

/**
 * 已有文件里存储了班级同学姓名，每一个姓名占一行，要求通过程序实现随机点名。
 */
public class CallNameDemo {
    public static void main(String[] args) {
        BufferedReader br = null;
        ArrayList<String> arr = new ArrayList<>();
        try {
            br = new BufferedReader(new FileReader("a1.txt"));
            String line = null;
            while ((line = br.readLine()) != null){
            arr.add(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        Random r = new Random();
        int index = r.nextInt(arr.size());
        String name = arr.get(index);
        System.out.println("幸运者是： " + name);
    }
}

5、（3）BufferedReader/BufferedWriter-->BufferedReader/PrintWrite

复制文件

第一种方法：BufferedReader/BufferedWriter

public static void main(String[] args) {
        try(
                BufferedReader br = new BufferedReader(new FileReader("a.txt"));
                BufferedWriter bw = new BufferedWriter(new FileWriter("a02.txt"));
                ) {
            String line = null;
            while ((line = br.readLine()) !=  null){
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

第二种方法：BufferedReader/PrintWrite

public static void main(String[] args) {
        try(
                BufferedReader br = new BufferedReader(new FileReader("a.txt"));
                PrintWriter pw = new PrintWriter(new FileWriter("a02.txt"), true);
                ) {
            String line = null;
            while ((line = br.readLine()) !=  null){
                pw.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }