IO流字节流输入输出格式

写入文件：
 1 import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import org.junit.Test;

public class FileOutputStream_Test {
    @Test
    public void fileOutputFormat() {

        OutputStream fos = null; // 扩大fos的作用域
        try {
            fos = new FileOutputStream("a.txt", true); // 指定写入的文件,加个TRUE可以不覆盖文件中已有内容
//            三种写入方式：
// 以字节形式写入文件，等价于fos.write(97);因为计算机读写文件是通过二进制编码读写的
            fos.write('a');

//    public void write(byte[] b) throws IOException   将 b.length 个字节从指定 byte 数组写入此文件输出流中。
            fos.write(new String("HelloWorld").getBytes());// 常用

//    public void write(byte[] b,int off, int len) throws IOException  将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
            fos.write(new String("HelloWorld").getBytes(), 2, 3);// 执行结果 llo

        } catch (Exception e) {
            System.out.println("指定路径不存在"); // 调用者使用
//            e.printStackTrace();         //程序员调试使用
        } finally {
//关闭流需要判断，如果之前指定路径就是错的，根本没有流的写入，如果这时关闭流，则会报异常，但是前面写的是异常的祖先，他爆出异常，后面的IO异常就被覆盖了。
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    System.out.println("流关闭错误");
//                    e.printStackTrace();
                }
            }
        }
    }

}

 读入文件

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import org.junit.Test;

public class FileInputStream_Test {
    public static void main(String[] args) {
        // fileInputFormat();
    }

    @Test // 单元测试不能加static
    public void fileInputFormat() {
        InputStream fis = null;
        byte[] bytes = new byte[1024];
        int length = -1;
        try {
            fis = new FileInputStream("Z:/a.txt");
            while ((length = fis.read(bytes)) != -1) {// fis.read(bytes)的返回值表示读取的数组中有效字节的个数，没有则是-1
                System.out.println(new String(bytes, 0, length));// 调用字符串的读取指定长度并输出
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件路径错误");
        } catch (IOException e) {
            System.out.println("流读入错误");
        } finally {
            if (fis != null) {// 关闭流
                try {
                    fis.close();
                } catch (Exception e) {
                    System.out.println("流关闭错误");
                }
            }
        }

    }
}

 

复制文件

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

import org.junit.Test;

public class FileCopy_Test {
    @Test
    public void copyFile() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("a.txt");
            fos = new FileOutputStream("aa.txt");
            byte[] bytes = new byte[1024];
            int length = -1;
            while ((length = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, length);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

使用字节缓冲流

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

import org.junit.Test;

public class BufferedIO_Test {
    @Test
    public void bufferedFile() throws IOException {
        InputStream fis = new FileInputStream("a.txt");
        OutputStream fos = new FileOutputStream("aa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);// 装饰者模式，字节缓冲流
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        byte[] bytes = new byte[1024];
        int length = -1;// 定义一个长度，该长度是读取数组返回的读取到的有效字节个数，没有就是-1，即最后一次数组多余存的都是-1
        while ((length = bis.read(bytes)) != -1) {// 读入一个数组，然后把这个数组中的有效字节写入文件
            bos.write(bytes, 0, length);
        }
        // 关闭流，先用的后关
        bos.close();
        bis.close();

    }

}