一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一 样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底 层传输的始终为二进制数据。

1. OutputStream

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
  • public abstract void write(int b) ：将指定的字节输出流。

注意：close方法，当完成流的操作时，必须调用此方法，释放系统资源。否则会产生内存泄漏。

OutputStream的子类：FileOutputStream

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

  • 写出字节数组： write(byte[] b) ，每次可以写出数组中的数据，代码使用演示：

    1. public class FOSWrite {
    2.   public static void main(String[] args) throws IOException {
    3.       // 使用文件名称创建流对象
    4.       FileOutputStream fos = new FileOutputStream("fos.txt");     
    5.         // 写出数据
    6.         byte[] b = "黑马程序员".getBytes();
    7.         // 关闭资源
    8.       fos.close();
    9.   }
    10. }
    11. 输出结果：
    12. 黑马程序员

  • 写出指定长度字节数组 ： write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：

    1. public class FOSWrite {
    2.   public static void main(String[] args) throws IOException {
    3.       // 使用文件名称创建流对象
    4.       FileOutputStream fos = new FileOutputStream("fos.txt");     
    5.         // 字符串转换为字节数组
    6.         byte[] b = "abcde".getBytes();
    7.       // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
    8.       fos.write(b,2,2);
    9.         // 关闭资源
    10.       fos.close();
    11.   }
    12. }
    13. 输出结果：
    14. cd

  • Append写入方式： public FileOutputStream(String name, boolean append)

  • 换行：
    • 回车符\r和换行符\n ：
      • 回车符：回到一行的开头（return）。
      • 换行符：下一行（newline）。
    • 系统中的换行：
      • Windows系统里，每行结尾是 回车+换行 ，即\r\n；
      • Unix系统里，每行结尾只有 换行 ，即\n；
      • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

InputStream

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

  • int read()：每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1 。

    1. // 使用文件名称创建流对象
    2. FileInputStream fis = new FileInputStream("read.txt");
    3. // 定义变量，保存数据
    4. int b;
    5. // 循环读取
    6. while ((b = fis.read())!=-1) {
    7.   System.out.println((char)b);
    8. }
    9. // 关闭资源
    10. fis.close();

    注意：虽然读取了一个字节，但是会自动提升为int类型。

  • int read(byte[] b)：每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1 

    1. // 使用文件名称创建流对象.
    2. FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
    3. // 定义变量，作为有效个数
    4. int len;
    5. // 定义字节数组，作为装字节数据的容器   
    6. byte[] b = new byte[2];
    7. // 循环读取
    8. while (( len= fis.read(b))!=-1) {
    9.   // 每次读取后,把数组变成字符串打印
    10.   System.out.println(new String(b));
    11. }
    12. // 关闭资源
    13. fis.close();

    使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

    实战：复制图片文件，代码使用演示：

    1. public class Copy {
    2.   public static void main(String[] args) throws IOException {
    3.       // 1.创建流对象
    4.       // 1.1 指定数据源
    5.       FileInputStream fis = new FileInputStream("D:\\test.jpg");
    6.       // 1.2 指定目的地
    7.       FileOutputStream fos = new FileOutputStream("test_copy.jpg");
    9.       // 2.读写数据
    10.       // 2.1 定义数组
    11.       byte[] b = new byte[1024];
    12.       // 2.2 定义长度
    13.       int len;
    14.       // 2.3 循环读取
    15.       while ((len = fis.read(b))!=-1) {
    16.           // 2.4 写出数据
    17.           fos.write(b, 0 , len);
    18.       }
    20.       // 3.关闭资源
    21.       fos.close();
    22.       fis.close();
    23.   }
    24. }