IO流

输入/输出流体系分类

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
抽象基类	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
特殊流	DataInputStream	DataOutputStream

二进制文件只能使用字节流进行读写，如音频、视频、图片等

根据数据的流向分为：输入流和输出流。

• 输入流 ：把数据从其他设备上读取到内存中的流。
• 输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

• 字节流 ：以字节为单位，读写数据的流，操作的数据单元是8位字节。
• 字符流 ：以字符为单位，读写数据的流，操作的数据单元是16位字符。

如果进行输入输出的内容是文本内容，则应该考虑使用字符流。

如果进行输入输出的内容是二进制内容，则该考虑使用字节流

File类

File类是java.io包下代表与平台无关的文件和目录，也就是说，如果希望在程序中操作文件和目录，都可以通过File类来完成，不管是文件还是目录都是使用File来操作，File能新建、删除、重命名文件和目录，File不能访问文件内容本身。如果需要访问文件没人本身，则需要使用输入、输出流。

字节流

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

输入数据的基本用法

//把硬盘里的数据输入到内存中使用
package com.snail.test.io;

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

public class FileInputStreamDemo1 {
  public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("/Users/snail/Documents/study/a.txt");
    byte[] bytes = new byte[1024];
    int len = 0;
    while ((len = fis.read(bytes)) != -1){
      System.out.println(new String(bytes,0,len));
    }
    fis.close();
  }
}

输出数据的基本用法

//把内存的数据输出到硬盘上
package com.snail.test.io;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo2 {
  public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream(new File("/Users/snail/Documents/study/a.txt"));
    String str = "雾锁山头山锁雾";
    byte[] bytes = str.getBytes();
    fos.write(bytes);
    fos.close();
  }
}

实例：

1、复制图片

FileInputStream fis = new FileInputStream("picture.jpg");
FileOutputStream fos = new FileOutputStream("d:\\picture.jpg");

int len;
byte[] bys = new byte[1024];

while((len = fis.read(bys)) != -1){
    fos.write(bys,0,len);
}

fos.close();
fis.close();

字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

flush和close的区别

• flush：刷新缓冲区，流对象可以继续使用。
• close：先刷新缓冲区，让后通知系统释放资源，流对象不可以在使用了。

缓冲流

缓冲流,也叫高效流，在基本的流对象基础之上创建而来的。缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

按照数据类型分类：

• 字节缓冲流：BufferedInputStream，BufferedOutputStream
• 字符缓冲流：BufferedReader，BufferedWriter

BufferedInputStream类example

package com.snail.test.buffered;


import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo1 {
  public static void main(String[] args) throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("/Users/snail/Documents/study/b.txt"));
    byte[] bytes = new byte[1024];
    int len=0;
    while ((len = bis.read(bytes)) != -1){
      System.out.println(new String(bytes,0,len));
    }
    bis.close();
  }
}

BufferedOutputStream类Example

package com.snail.test.buffered;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo1 {
  public static void main(String[] args) throws IOException {
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("/Users/snail/Documents/study/a.txt"));
    bos.write("我也不知道写点什么".getBytes());
    bos.close();
  }
}

BufferedReader 类example

package com.snail.test.buffered;

import java.io.*;

public class BufferedChar {
  public static void main(String[] args) throws IOException {
    BufferedReaderDemo1();
  }

  private static void BufferedReaderDemo1() throws IOException {
    BufferedReader br = new BufferedReader(new FileReader("/Users/snail/Documents/study/c.txt"));
    String line;
    while ((line = br.readLine())!=null){
      System.out.println(line);
    }
    br.close();
  }
}

BufferedWriter类 example

package com.snail.test.buffered;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedChar {
  public static void main(String[] args) throws IOException {
    BufferedWriterDemo1();
  }

  private static void BufferedWriterDemo1() throws IOException {
    BufferedWriter bw = new BufferedWriter(new FileWriter("/Users/snail/Documents/study/c.txt"));
    for (int i = 0; i < 10; i++) {
      bw.write("随便写点撒子");
      bw.newLine();
    }
    bw.close();
  }
}

综合练习文本排序

package com.snail.test.buffered;

import java.io.*;
import java.util.Arrays;
import java.util.HashMap;

public class BufferedChar {
  public static void main(String[] args) throws IOException {
    ExampleSort();
  }

  private static void ExampleSort() throws IOException {
    HashMap<String, String>  map = new HashMap<>();
    BufferedReader br = new BufferedReader(new FileReader("/Users/snail/Documents/study/in.txt"));
    BufferedWriter bw = new BufferedWriter(new FileWriter("/Users/snail/Documents/study/out.txt"));
    String line;
    while ((line = br.readLine()) != null){
      String[] arr = line.split("\\.");
      map.put(arr[0],arr[1]);
    }
    for(String key : map.keySet()){
      String value = map.get(key);
      bw.write(key+"."+value);
      bw.newLine();
    }
    br.close();
    bw.close();
  }
}

转换流

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

**编码:**字符(能看懂的)--字节(看不懂的)

**解码:**字节(看不懂的)-->字符(能看懂的)

字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

编码表:生活中文字和计算机中二进制的对应规则

字符集

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

ASCII字符集 ：

• ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
• 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。

ISO-8859-1字符集：

• 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
• ISO-8859-1使用单字节编码，兼容ASCII编码。

GBxxx字符集：

• GB就是国标的意思，是为了显示中文而设计的一套字符集。
• GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。
• GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。
• GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。

Unicode字符集 ：

• Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
• 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
• UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
  1. 128个US-ASCII字符，只需一个字节编码。
  2. 拉丁文等字符，需要二个字节编码。
  3. 大部分常用字（含中文），使用三个字节编码。
  4. 其他极少使用的Unicode辅助字符，使用四字节编码。

OutputStreamWriter类example

package com.itheima.demo03.ReverseStream;

import java.io.*;

/*
    练习：转换文件编码
        将GBK编码的文本文件，转换为UTF-8编码的文本文件。

    分析:
        1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK
        2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8
        3.使用InputStreamReader对象中的方法read读取文件
        4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中
        5.释放资源
 */
public class Demo04Test {
    public static void main(String[] args) throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\我是GBK格式的文本.txt"),"GBK");
        //2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\我是utf_8格式的文件.txt"),"UTF-8");
        //3.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            //4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中
            osw.write(len);
        }
        //5.释放资源
        osw.close();
        isr.close();
    }
}

序列化流

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。

一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
      	System.out.println("Address  check : " + name + " -- " + address);
    }
}

序列化流example

package com.snail.test.buffered;

import java.io.Serializable;

public class Person implements Serializable {
  private String name;
  private int age;
  public Person() {
  }
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  public String getName() {return name; }
  public void setName(String name) { this.name = name; }
  public int getAge() { return age; }
  public void setAge(int age) { this.age = age; }
}

package com.snail.test.buffered;

import java.io.*;
import java.util.ArrayList;

public class CommonTest {
  public static void main(String[] args) throws IOException, ClassNotFoundException {
    //1、创建一个ArrayList集合
    ArrayList<Person> list = new ArrayList<>();
    //2、添加数据
    list.add(new Person("张三",28));
    list.add(new Person("李斯",24));
    list.add(new Person("王武",25));
    list.add(new Person("赵六",22));
    //3、创建个对象字节输出流，序列化
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("/Users/snail/Documents/study/list.txt"));
    //4、把集合写到list.txt中
    oos.writeObject(list);
    //5、创建一个对象字节输入流,反序列化。
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/snail/Documents/study/list.txt"));
    //6、从list.txt文件中读取数据强转成ArrayList<Person>集合对象
    ArrayList<Person> person = (ArrayList<Person>) ois.readObject();
    //7、遍历对象
    for (Person p : person) {
      System.out.println(p.getName()+"="+p.getAge());
    }
    //8、释放资源
    oos.close();
    ois.close();
  }
}

打印流

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

public class PrintDemo {
    public static void main(String[] args) throws IOException {
		// 调用系统的打印流,控制台直接输出97
        System.out.println(97);
      
		// 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
      	
      	// 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
      	// 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}