前言

InputStream 抽象了应用程序读取数据的方式；

OutputStream 抽象了应用程序写入数据的方式；

2. EOF = End 读到 -1 就读到结尾, -1 是EOF；

3. 输入流基本方法

int b = in.read(); 读取一个字节无符号填充到 int 的低8位。

in.read(byte[] bug); 读取数据填充到字节数组 buf；

in.read(byte[] buf,int start,int size) 读取数据到字节数组 buf，从 buf 的 start 位置开始存放 size 长度的数据；

4. 输入流基本方法

out.write(int b) 写出一个 byte 到流，b 的低8位；

out.write(byte[] buf) 将 buf 字节数组都写入到流；

out.write(byte[] buff,int start, int size) 字节数组 buf 从 start 位置开始写 size 长度的字节到流；

一、FileInputStream & FileOutputStream 类

FileInputStream ---> 具体实现了在文件上读取数据； FileOutputStream ---> 实现了向文件中写入 byte 数据的方法；

1、读取文件内容，按照16进制输入到控制台，并且每输出10个byte换行：

public static void printHexByByteArray(String filename) throws IOException {
    FileInputStream in = new FileInputStream(filename);
    byte[] buf = new byte[20 * 1024];
    int s = 1;
    int c;
    // 从 in 中批量读取字节放入到 buf 这个字节数组中，从第 0 个位置开始放，最多放 buf.length 个,返回的是读到的字节的个数
    while ((c = in.read(buf, 0, buf.length)) != -1) {
        for (int i=0; i<c; i++) {
            if (buf[i] <= 0xf) {
                System.out.print("0");
            }
            System.out.print(
                    // byte类型 8 位，int类型 32 位，
                    // 为了避免数据转换错误，通过 &0xff 将高 24 位清零
                    Integer.toHexString(buf[i] & 0xff) + " "
            );
            if (s++%10 == 0) {
                System.out.println();
            }
        }
    }
    in.close();
}

2、读取源文件的所有内容，并复制到新文件：

public static void copyFile(String srcFileName, String dstFileName) throws IOException {
    // 参数判断
    File srcFile = new File(srcFileName);
    File dstFile = new File(dstFileName);
    if (!srcFile.exists()) {
        throw new IllegalArgumentException("文件：" + srcFileName + "不存在！");
    }
    if (!srcFile.isFile()) {
        throw new IllegalArgumentException(srcFileName + "不是文件");
    }

    // 输入文件流
    FileInputStream in = new FileInputStream(srcFile);
    
    // 输入文件流
    // 如果该文件不存在，则直接创建，如果存在，删除后创建;
    // 往已有文件内追加内容，需要增加第二个参数 true;
    FileOutputStream out = new FileOutputStream(dstFile);
    
    byte[] buf = new byte[10*1024];
    int c;
    while ((c = in.read(buf, 0 ,buf.length)) != -1) {
        out.write(buf, 0, c);
        // 刷新缓冲区，最好加上
        out.flush(); 
    }
    in.close();
    out.close();
}

二、DataInputStream & DataOutputStream 类

DataInputStream/DataOutputStream 可视为 FileInputStream/FileOutputStream 的装饰模式； 其对“流”功能的扩展，可以更加方便地读取int、long、字符等类型数据。

String fileName = "D:\\Imooc\\file\\test\\dos.dat";

// 文件写入：
DataOutputStream dos = new DataOutputStream(
        new FileOutputStream(fileName)
);
dos.writeInt(10);
dos.writeInt(-10);
dos.writeLong(10L);
dos.writeDouble(10.5);
// 采用utf-8编码写出
dos.writeUTF("测试");
// 采用urf-16be编码写出
dos.writeChars("测试");
dos.close();
IOUtil.printHexByByteArray(fileName);
System.out.println();

// 文件读取：
DataInputStream dis = new DataInputStream(
        new FileInputStream(fileName)
);
int i = dis.readInt();
System.out.println(i);
i = dis.readInt();
System.out.println(i);
long l = dis.readLong();
System.out.println(l);
double d = dis.readDouble();
System.out.println(d);
String s = dis.readUTF();
System.out.println(s);
dis.close();

三、BufferedInputStream & BufferedOutputStream 类

这两个流类为 IO 提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提供了 IO 的性能。 从应用程序中把输入放入文件，相当于将一缸水倒入另一个缸中： FileOutputStream ---> write() 方法相当于一滴一滴地把水“转移”过去； DataOutputStream ---> writeXxx() 方法会更方便一些，相当于一瓢一瓢地把水“转移”过去； BufferOutputStream ---> write() 方法会更方便，相当于一瓢一瓢先放入桶中，再从桶中倒入到另一个缸中；

public static void copyFileByBuffer(String srcFileName, String dstFileName) throws IOException {
    // 参数判断
    File srcFile = new File(srcFileName);
    File dstFile = new File(dstFileName);
    if (!srcFile.exists()) {
        throw new IllegalArgumentException("文件：" + srcFileName + "不存在！");
    }
    if (!srcFile.isFile()) {
        throw new IllegalArgumentException(srcFileName + "不是文件");
    }

    BufferedInputStream bis = new BufferedInputStream(
            new FileInputStream(srcFile)
    );
    BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(dstFile)
    );

    int c;
    while((c = bis.read()) != -1) {
        bos.write(c);
        // 刷新缓冲区，最好加上
        bos.flush();
    }
    bis.close();
    bos.close();
}

---