1.什么是IO

I:Input
O:Output
通过IO可以完成硬盘文件的读和写。
IO流又叫输入输出流，输入和输出均是以内存作为参照物。
在这里插入图片描述

2. I/O流的分类?

2.1 输入流，输出流

以内存作为参照物，
往内存中去，叫做输入，或者叫做读。
从内存中出来，叫做输出，或者叫做写。

2.2 字节流，字符流

字节流
按照字节的方式读取数据，一次读取1个字节byte,等同于一次读取8个二进制位。这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视频文件。
example:
假设文件file1.txt,采用字节流的话是这样读的:
a中国bo张三fe：
第一次读: 一个字节,正好读"a"。
第二次读:一个字节,正好读到"中"字符的一半。
第三次读: 一个字节,正好读到"中字符的另外一半。

字符流
按照字符的方式读取数据, 一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。
example：
假设文件file1.txt,采用字符流的话是这样读的:
a中国bo张三fe：
第一次读:'a’字符('a’字符在windows系统中占用1个字节)
第二次读:'中’字符('中’字符在windows系统中占用2个字节)

3. I/O流所使用的具体抽象类

java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
所有的流都实现了:java.io.Colseable接口，都是可关闭的，都有close()方法. 流毕竟是一个管道，这个是内存和硬盘之间的通道，养成一个好习惯，用完流将其关闭。
所有的输出流都实现了:java.io.Flushable接口，都是可刷新的，都有flush()方法。养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完(清空管道!)刷新的作用就是清空管道。如果没有flush()可能会导致数据丢失.
注意:在java中只要"类名"以Stream结尾的都是字节流。以"Reader/Writer"结尾的都是字符流。

4.Java.io 包下常用的流（16个）

文件专属
java.io.FileinputStream   (用得最多)
java.io.FileOutputStream  (用得最多)
java.io.FileReader
java.io.FileWriter

转换流:(将字节流转换成字符流)
java.io.InputStreamReader
java.io.outputStreamWriter

缓冲流专属:
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream

数据流专属:
java.io.DataInpoutStream
java.io.DataOutputStream

标准输出流:
java.io.PrintWriter
java.io.PrintStream
    
对象专属流:（掌握）
java.io.ObjectInputStream
java.io.ObjectOutputStream

5.FileInputStream详解

文件字节输入流，万能的，任何类型的文件都可以采用这个流来读
以字节的方式，完成输入的操作，完成读的操作(硬盘 —> 内存)
样例1：读取操作
比如我现在要读取这样内容的一个文本文件
在这里插入图片描述
可以采用InputStream中的read()方法，它每次会读取一个字节。
英文会读取一个字母，汉字读取半个字符或三分之一个字符。
（因为GBK的一个汉字占两个字节，UTF-8的汉字占3个）
读到文件末尾时read()方法会返回-1

    FileInputStream fis = new FileInputStream("C:\\Users\\86185\\Desktop\\temp.txt");
        // 开始读
        int a = fis.read(); // a对应的10进制数值
        int b = fis.read(); // b对应的10进制数值
        int c = fis.read(); // c对应的10进制数值
        int d = fis.read(); // d对应的10进制数值
        int e = fis.read(); // e对应的10进制数值
        int none = fis.read(); // 读到末尾没有值了
        // 如果读不到数据  则返回负一
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
        System.out.println(none);

        fis.close();

输出结果为
在这里插入图片描述

样例2:
一般开发时，会循环读取里面的内容，一次读取一个字节byte。
但同时，内存和硬盘交互太频繁，基本时间/资源都耗费在交互上面了

   FileInputStream fis = null;
   // 指向一个文件
    fis = new FileInputStream("D:\\Desktop\\temp.txt");
    while(true){
        int read = fis.read();
        if(read==-1){  // 读到末尾的时候返回值为-1
            break;
        }
        System.out.println(read);
    }
    if(fis != null){
        fis.close();
    }

最终样例3：
当read方法中的参数为byte[]数组时
该方法的返回值为byte[]数组在文件中读取的字节数量
而此时的byte[]数组中的内容为在目标文件中所读取的内容。

    FileInputStream fis = null;
    fis = new FileInputStream("tempfile");
    // 准备一个byte数组
    byte[] bytes = new byte[1024];
    int readCount;
    while((readCount = fis.read(bytes))!=-1){
        // 把byte数组转换成字符串，读到多少个转换多少个
        System.out.print(new String(bytes,0,readCount));
    }
    if(fis!=null){
        fis.close();
    }

补充：FileInputStream类的其它方法

   int available();  // 返回流当中的剩余的没有读到的字节数量
   long skip(long n); // 跳过几个字节不读

6.FileOutputStream详解

文件字节输出流，负责写，从内存到硬盘
样例1,输出功能演示
注意追加内容一定要携带参数true，否则会清空源文件内容

	FileOutputStream fos = null;
     // 不清空原文件的方式写入  则选择以追加的方式写入  不会清空原文件内容
     // true表示追加
     fos = new FileOutputStream("myfile1",true); 
     
      // 开始写
     byte[] bytes = {97,98,99,100};
     
     // 将byte数组全部写出
     fos.write(bytes); // abcd
     
     // 将byte数组的一部分写出
     fos.write(bytes,0,2); //ab
     
     // 将字符串转换为byte数组
     String s = "我是一个中国人,我骄傲";
     byte[] bytes1 = s.getBytes();
     fos.write(bytes1);
     
     fos.flush();

样例2,文件的拷贝
先从硬盘中读取到文件里面，再通过内存写入硬盘从而完成文件的复制。使用FileInputStream + FileOutputStream 完成文件的拷贝拷贝的过程应该一边读，一边写。使用以上字节流拷贝文件的时候，文件的类型随意，万能的，什么样的文件都能拷贝。

	 FileInputStream fis = null;
     FileOutputStream fos = null;
     // 创建一个输入流对象
     fis = new FileInputStream("myfile");
     // 创建一个输出流对象
     fos = new FileOutputStream("myfile2");
     // 最核心的: 一边读，一边写(1024个字节是1kb)
     byte[] bytes = new byte[1024 * 1024]; // 一次拷贝1M
     int readCounts = 0;
     while((readCounts = fis.read(bytes)) != -1){
         fos.write(bytes,0,readCounts);
     }
     // 刷新，输出流最后要刷新
     fos.flush();
     fis.close();
     fos.close();

7.FileReader详解

样例1：基本使用
文件字符输入流。只能读取普通文本
因为是字符输入流，故此处创建的是char[]数组而不是byte[]数组

 	// 创建文件字符输入流
	FileReader reader = new FileReader("tempfile");
    // 开始读
    char[] chars = new char[10];
    int readCounts = 0;
    while((readCounts = reader.read(chars)) != -1){
        System.out.print(new String(chars,0,readCounts));
    }
    reader.close();

8.FileWriter详解

样例1：基本使用
文件字符输出流，写，只能输出普通文本
FileReader和FileWriter可以操作普通文本，
但是不能操作其它非普通文本文件
(word不是普通文本，普通文本也与文件后缀名无关)

    FileWriter out = null;
    // 初始化一个文件字符输出流对象
    out = new FileWriter("file"); // 不想清空 一直累加的话  可以在此处加true
    // 开始写
    char[] chars = {'我','是','中','国','人'};
    // 刷新
    out.write(chars);
    out.write(chars,0,2);
    out.write("我是一名java工程师!");
    out.flush();

样例2：拷贝文件
使用FIleReader + FileWriter进行拷贝(只能拷贝普通文件)

    FileReader fileReader = null;
    FileWriter fileWriter = null;
    // 创建一个输入流
    fileReader = new FileReader("myfile");
    // 创建一个输出流(没有文件会先自己创建)
    fileWriter = new FileWriter("myfile00");
    char[] chars = new char[1024*1024];
    int readCounts = 0;
    while((readCounts = fileReader.read(chars))!=-1){
        fileWriter.write(chars,0,readCounts);
    }
    fileWriter.flush();
    fileReader.close();
    fileWriter.close();

9.BufferedReader详解

带有缓冲区的字符输入流，使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组，自带缓冲。
样例1:基本使用
概念：
当一个流的构造方法中需要一个流的时候,这个被传进来的流叫做: 节点流.
外部负责包装的这个流,叫做:包装流，还有一个名字叫做 : 处理流
像当前这个程序来说: FileReader就是一个节点流。
BufferedReader就是包装流/处理流。

	FileReader fileReader = new FileReader("myfile");
    BufferedReader bufferedReader = new BufferedReader(fileReader);

//        // 读第一行
//        String s = bufferedReader.readLine();
//        System.out.println("第一行: "+s);
//
//        // 读第二行
//        String s1 = bufferedReader.readLine();
//        System.out.println("第二行:"+s1);

    // 循环读出来   这种方式  读到末尾返回值为null
    // readLine() 方法读取一个文本行，但不带换行符。
    String s ;
    while((s = bufferedReader.readLine())!=null){
        System.out.println(s);
    }
    // 关闭流
    // 对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭！
    bufferedReader.close();

样例2：节点流可以是FileReader也可以是InputStreamReader

BufferedReader br = new BufferedReader(new InputStreamReader((new FileInputStream("myfile"))));
String line = null;
while((line=br.readLine())!= null){ // 一行一行的读  没有读到null就代表读到了
    System.out.println(line);
}

10.BufferedWriter详解

带有缓冲区的字符输出流

  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("copy1",true)));
  bw.write("hello world");
  bw.write("\n");
  bw.write("i love you");
  // 刷新(输出流好习惯)
  bw.flush();
  // 关闭最外层
  bw.close();

11.DataOutputStream详解

这个流可以将数据连同数据的类型一并写入文件，但是这个文件不是普通文本文档。

 // 创建数据专属的字节输出流
  DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
  // 写数据
  byte b =100;
  short s =200;
  int i =300;
  long l = 400L;
  float f =3.0f;
  double d = 3.14;
  boolean sex = false;
  char c = 'a';
  // 写
  dos.writeByte(b);
  dos.writeShort(s);
  dos.writeInt(i);
  dos.writeFloat(f);
  dos.writeBoolean(sex);
  dos.writeDouble(d);
  dos.flush();
  dos.close();

12.DataInputStream详解

数据字节写入流。
DataOutputStream写的文件，只能使用DataInputStream去读
并且读的时候需要提前知道写入的顺序。
读的顺序和写的顺序一致，才可以正确取出数据。

  DataInputStream dis = new DataInputStream(new FileInputStream("data"));
  // 开始读
  Byte b = dis.readByte();
  Short s = dis.readShort();
  int i = dis.readInt();
  Float f = dis.readFloat();
  Boolean sex = dis.readBoolean();
  Double d = dis.readDouble();

  System.out.println(b);
  System.out.println(s);
  System.out.println(i);
  System.out.println(f);
  System.out.println(sex);
  System.out.println(d);