I/O

InputStream和Reader是所有输入流的基类，其典型实现是FileInputStream和FileReader

下面的代码是字节输入流FileInputStream读取文件内容的3中方式：

public void IOTest() throws Exception {

        //1、创建一个字节输入流
        InputStream inputStream = new FileInputStream("aaa.txt");
        
        //2读取文件内容
        // 2.1一次读取一个字节，不建议这么读，效率太低
        int result = inputStream.read();
        while(result !=-1){
            System.out.print((char)(result));
            result = inputStream.read();
        }

        //2.2一次读取一个数组：一组字节
        byte[] buffer = new byte[10];
        int len = 0;
        //返回值为一次读取的字节数，若为-1则表示读到文件尾
        while((len = inputStream.read(buffer)) != -1){
            for(int i = 0;i<len;i++){
                System.out.print((char)buffer[i]);
            }
        }

        //2.3把字节读到字节数组中的一个连续空间
        byte[] result = new byte[1024];
        inputStream.read(result,10,inputStream.available());


        inputStream.close();

    }

 同样字符流FileReader读取文件内容也有3种方法：

 @Test
    public void readerTest() throws IOException {
        Reader reader = new FileReader("aaa.txt");
        char[] buffer = new char[10];
        int len = 0;
        while((len = reader.read(buffer))!= -1){
            for(int i = 0;i<len;i++){
                System.out.print(buffer[i]);
            }
        }

        reader.close();

 使用字节输入输出流实现文件复制

@Test
    public void copyTestByInputAndOutput() throws Exception {

        //1.创建定位到文件的字节输入流
        InputStream in = new FileInputStream("abcde.txt");

        //2.创建定位到文件的字节输出流
        OutputStream out = new FileOutputStream("abcde2.txt");


        //3.创建byte数组
        byte[] buffer = new byte[1024 * 10];
        int len = 0;

        //4.读取文件，写入另一个文件
        while((len = in.read(buffer))!= -1){
            out.write(buffer,0,len);
        }

        //4.关闭资源
        out.close();
        in.close();
    }

使用字符输入输出流实现文件复制

public void copyTestByReaderAndWriter()throws IOException{
        Reader reader = new FileReader("abcde.txt");
        Writer writer = new FileWriter("abcde2.txt");

        char[] buffer = new char[10];
        int len = 0;

        while((len = reader.read(buffer))!= -1){
            writer.write(buffer,0,len);
        }

        reader.close();
        writer.close();
    }

使用缓冲流实现文件复制

@Test
    public void testBufferedReaderAndBufferedWriter()throws IOException{

        //1.创建输入输出流，BufferedReader和BufferedWriter是一个包装流，也就是在
        //创建它们时，必须传入Reader和Writer
        Reader in = new FileReader("abcde.txt");
        BufferedReader bufferedReader = new BufferedReader(in);

        Writer out = new FileWriter("abcde3.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(out);

        //2.进行读写操作,缓冲流可以每次读取一行，效率相对较高
        String str = null;
        int i =0;
        while((str = bufferedReader.readLine())!= null){
            if( i != 0){
                bufferedWriter.write("\n");
            }
            bufferedWriter.write(str);
            i = i +1;
        }

        //3.关闭包装流，包装流内部会关闭节点流
        bufferedReader.close();
        bufferedWriter.close();
    }

    @Test
    public void testBufferedInputStreamAndBufferedOutStream() throws IOException {
        InputStream in = new FileInputStream("abcde.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(in);

        OutputStream out = new FileOutputStream("abcde5.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(out);

        byte[] buffer = new byte[1024];
        int len = 0;
        while((len = bufferedInputStream.read())!= -1){
            bufferedOutputStream.write(buffer,0,len);
        }

        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

转换流，只能是字节转字符，因为字节流使用于所有文件，字符流只适用于文本文件当获取到的流是一个字节流，但是这个流对应的是一个字符文件，可以用转换流进行转换，操作起来更方便

@Test
    public void testInputStreamReader()throws IOException{
        //1.创建字节流
        InputStream in = new FileInputStream("abcde.txt");

        //2.将字节流转换成字符流
        Reader reader = new InputStreamReader(in);

        //3.将字符流转换成带缓冲的字符流
        BufferedReader  bufferedReader = new BufferedReader(reader);

        String str = null;
        while((str = bufferedReader.readLine())!= null){
            System.out.println(str);
        }

        //4.关闭流
        in.close();
        reader.close();
        bufferedReader.close();

    }

    //实现文件复制
    @Test
    public void testOutputStreamWriter()throws IOException{
        InputStream in = new FileInputStream("abcde.txt");
        Reader reader = new InputStreamReader(in);
        BufferedReader bufferedReader = new BufferedReader(reader);

        OutputStream out = new FileOutputStream("abcde6.txt");
        Writer writer = new OutputStreamWriter(out);
        BufferedWriter bufferedWriter= new BufferedWriter(writer);

        String str = null;
        int i = 0;
        while((str = bufferedReader.readLine())!= null){
            if(i != 0){
                bufferedWriter.write("\n");
            }
            i = i + 1;
            bufferedWriter.write(str);

        }

        in.close();
        reader.close();
        bufferedReader.close();

        bufferedWriter.close();
        writer.close();
        out.close();
    }