IO流（输入输出流（字节、字节缓冲、文件字符、文件字符缓冲）、IO流的应用、缓冲数组）

1、输出流

（1）字节输出流：FileOutputStream

OutputStream是输出流的超类，它是一个抽象类。

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\IO流\java\1.txt");
        FileOutputStream f = new FileOutputStream(file, true);// 加true后可以实现续写功能
        String str = "
" + "nihao";// 换行
        f.write(str.getBytes());
        f.write("你好".getBytes());
        f.write(8);
        f.close();//释放输出流的资源占用

    }
}

（2）字节缓冲输出流：BufferedOutputStream

write（）方法所写的数据并不是直接写入到外设，而是先存放到缓冲区中，积累到一定程度再写到外设，这样可以提高系统效率。但有的时候缓冲区不满就需要写到外设上，需要调用flush（）方法。

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\IO流\java\123.txt");
        FileOutputStream f = new FileOutputStream(file, true);// 加true后可以实现续写功能
        BufferedOutputStream bos = new BufferedOutputStream(f);

        bos.write("你好".getBytes());

        bos.close();
    }
}

（3）OutputStream与BufferedOutputStream效率对比：

使用缓冲流：

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\IO流\java\123.txt");
        FileOutputStream f = new FileOutputStream(file, true);// 加true后可以实现续写功能
        BufferedOutputStream bos = new BufferedOutputStream(f);
        long startTime = System.currentTimeMillis();
        for(int i=1;i<=1000;i++)
        bos.write("你好".getBytes());
        long endTime = System.currentTimeMillis();
        System.out.println("执行此程序用了" + (endTime - startTime) + "毫秒。");
        bos.close();

    }
}

未使用缓冲流：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\IO流\java\123.txt");
        FileOutputStream f = new FileOutputStream(file, true);// 加true后可以实现续写功能

        long startTime = System.currentTimeMillis();
        for (int i = 1; i <= 1000; i++)
            f.write("你好".getBytes());
        long endTime = System.currentTimeMillis();
        System.out.println("执行此程序用了" + (endTime - startTime) + "毫秒。");
        f.close();

    }
}

（4）文件字符输出流：FileWriter

import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
    FileWriter fw = new FileWriter("E:\IO流\java\1.txt");
    char []c={'n','i','h','a','o'};
    String str="我爱java";
    fw.write(c);
    fw.write("	
"+"你好java"+"	
");//先编码
    fw.write(str, 0, 2);
    fw.flush();
    fw.close();

}
}

（5）字符缓冲输出流：BufferWriter

package pers.aaa.Writer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferWriter {
public static void main(String[] args) throws IOException {
    FileWriter fw = new FileWriter("E:\IO流\java\1.txt");
    BufferedWriter out = new BufferedWriter(fw);
    char []c={'n','i','h','a','o'};
    String str="我爱java";
    out.write(c);
    out.newLine();
    out.write("你好java");//先编码
    out.newLine();
    out.write(str, 0, 2);
    out.flush();
    out.close();

}
}

2、输入流

（1）字节输入流：InputStream

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\IO流\java\1.txt");
        FileInputStream f = new FileInputStream(file);
        int n = 0;
        while ((n = f.read()) != -1) {
            System.out.print((char) n);

        }
        f.close();
    }
}

能够读取到文件上的数据：

（2）字节输入缓冲流：BufferedInputStream

package pers.zaw.in;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\IO流\java\1.txt");
        FileInputStream f = new FileInputStream(file);
        BufferedInputStream in = new BufferedInputStream(f);
        int n = 0;

        while ((n = in.read()) != -1) {
            System.out.print((char) n);

        }

        in.close();
    }
}

（3）字符输入：FileReader

FileReader继承自InputStreamReader类，InputStreamReader类继承自Reader类。

import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //读取文字
        FileReader fr = new FileReader("E:\IO流\java\1.txt");
        int ch = 0;
        while ((ch = fr.read()) != -1) {
            // 输出的字符对应的编码值
            System.out.print(ch);
            System.out.print((char) ch);
            System.out.println();
        }
        //写入文字
        FileOutputStream fos = new FileOutputStream("E:\IO流\java\8.txt");
        fos.write("读取文件".getBytes());//编码过程
        fos.close();

    }
}

（4）字符缓冲输入流：BufferedReader

package pers.was.Reader;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        // 读取文字

        BufferedReader in = new BufferedReader(new FileReader(
                "E:\IO流\java\1.txt"));
        int ch = 0;
        while ((ch = in.read()) != -1) {
            // 输出的字符对应的编码值
            System.out.print(ch);
            System.out.print((char) ch);
            System.out.println();
        }

    }
}

（5）readLine（）读取一个文本行

package pers.was.Reader;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        // 读取文字
        FileReader fr=new FileReader("E:\IO流\java\1.txt");
        BufferedReader in = new BufferedReader(fr);
        String line = null;
        while( (line = in.readLine()) != null ){
            System.out.println(line);
        }
        
        //3,关闭流
        in.close();


    }
}

3、应用

（1）文件复制：

用FileInputStream和FileOutPutStream实现文件的复制，此方法不能复制文件夹。

package pers.zhh.copy;

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

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fi = new FileInputStream("M:\数据库.zip");
        FileOutputStream fo = new FileOutputStream("M:\数据库1.zip");
        int num = 0;
        long startTime = System.currentTimeMillis();
        while ((num = fi.read()) != -1) {
            fo.write(num);

        }
        fo.close();
        fi.close();
        long endTime = System.currentTimeMillis();
        System.out.println("执行此程序用了" + (endTime - startTime) + "毫秒。");
    }
}

 （2）缓冲数组实现复制：

package pers.zzz.copy;

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

public class CopyDemo1 {
    public static void main(String[] args) throws IOException {
        FileInputStream fi = new FileInputStream("M:\网页设计.zip");
        FileOutputStream fo = new FileOutputStream("M:\网页设计3.zip");
        byte[] buf = new byte[1024];
        int len = 0;
        long startTime = System.currentTimeMillis();
        while ((len = fi.read(buf)) != -1) {
            fo.write(buf, 0, len); // 将数组中的指定长度的数据写入到输出流中。
        }
        fo.close();
        fi.close();
        long endTime = System.currentTimeMillis();
        System.out.println("执行此程序用了" + (endTime - startTime) + "毫秒。");
    }

}

在第一个方法中，一次只能读取一个数据字节，复制只有几M的数据花了7s时间，效率极低。而第二种采用缓冲数组的方式，复制接近1G的文件只花费了4s的时间，效率大大提升。

（3）IO流的异常处理

package pers.zzz.copy;

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

public class CopyDemo1 {
    public static void main(String[] args) {
        FileOutputStream fo = null;
        FileInputStream fi = null;
        long startTime = System.currentTimeMillis();
        try {
            fi = new FileInputStream("M:\网页设1计.zip");
            fo = new FileOutputStream("M:\网页设计11.zip");

            byte[] buf = new byte[1024];
            int len = 0;

            while ((len = fi.read(buf)) != -1) {
                fo.write(buf, 0, len); // 将数组中的指定长度的数据写入到输出流中。
            }
        } catch (IOException e) {
            System.out.println(e.toString());
        } finally {
            if (fo != null) {
                try {
                    fo.close();
                } catch (IOException e) {
                    System.out.println(e.toString());
                    throw new RuntimeException();
                }
            }
            if (fi != null) {
                try {
                    fi.close();
                } catch (IOException e) {
                    System.out.println(e.toString());
                    throw new RuntimeException();

                }

            }

        }
        long endTime = System.currentTimeMillis();

        System.out.println("执行此程序用了" + (endTime - startTime) + "毫秒。");
    }
}

 4、缓冲流的好处

如果没有缓冲流，则是读一个数据写一个数据，耗费了较多的时间。

应用了缓冲流之后，则是等到缓冲区满的时候，或是调用了flush（）；函数后才会输出，提高了效率。

5、缓冲数组的一个问题

（1）题目

（2）验证

在磁盘中创建一个文件，用于被输入流读取：

 读取后输出，验证

 这里牵涉到缓冲数组的特点。