Io流

字符流
OutputStreamWriter
字符流要刷新一下，才会将缓存中的数据，写入到硬盘
writer.flush();是刷新缓冲区的方法

InputStreamReader
一次读取一个字符，写入一个字符，来复制文本文件
一次读取一个字符数组，来复制文本文件
InputStreamReader in = new InputStreamReader(new FileInputStream(“c.txt”));
char[] chars = new char[1000];
//一次读取一个字符数组
// int len = in.read(chars); //返回值是读取到的有效的字符个数
//一次读取一个字符数组的一部分
int len = in.read(chars); //返回值是读取到的有效的字符个数

便捷子类
父类 子类 (便捷类)
OutputStreamWriter--------FileWriter
InputStreamReader---------FileReader
高效的字符流
1.BufferedWriter
BufferedWriter 里面有一个特有的方法 还可以直接写一个字符串，void newLine () 写入一个换行符，具有平台兼容性
2.BufferedReader
BufferedReader 里面有一个特有的方法 String readLine () 一次取一行文本
//BufferedReader 里面有一个特有的方法 String readLine () 一次取一行文本

BufferedReader in = new BufferedReader(new FileReader(“MyTest.java”));

//BufferedWriter 里面有一个特有的方法 void newLine () 写入一个换行符，具有平台兼容性
BufferedWriter out = new BufferedWriter(new FileWriter(“E:\MyTest4.java”));

//采用读取一行写人一行来复制文件
String line = null;
while ((line = in.readLine()) != null) { //读取不到返回 null
out.write(line);
out.newLine();
out.flush();
}
in.close();
out.close();

编码
编码：把看的懂，转成看不懂的
解码：把看不懂，转成看的懂得
乱码产生的原因：编解码使用的不是同一个码表
byte[] getBytes ()
使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] getBytes (Charset charset)
使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。
byte[] bytes = “你好中国”.getBytes(“UTF-8”);

  6.String( byte[] bytes)

通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
7.String( byte[] bytes, Charset charset)
通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
String s = new String(bytes, “UTF-8”);

杂七杂八IO类
// 数据输入输出流：特点就是能够读写基本数据类型
DataOutputStream
// 数据输入输出流：特点就是能够读写基本数据类型
//注意读取的顺序，刚才怎么写的，就怎么读
DataInputStream

内存操作流，在内存中进行读写操作，不关联文件

操作字节数组
ByteArrayOutputStream
ByteArrayInputStream
1.此流关闭无效，所以无需关闭
2.ByteArrayOutputStream //此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用toByteArray () 和 toString () 获取数据。

操作字符数组
CharArrayWrite
CharArrayReader
操作字符串
StringWriter
StringReader
打印流
打印流：只是写，不操作源文件 就是单个的一个流，只用来输出
字节打印流 PrintStream
字符打印流 PrintWriter
PrintStream out2 = System.out; //他关联的设备是屏幕
out2.println(“abc”);

//这种方式关联的是文件
PrintStream stream = new PrintStream(new File(“c.txt”));

stream.println(“abc”);
stream.println(“abc”);
stream.println(“abc”);
stream.println(“abc”);
stream.println(“abc”);
stream.println(“abc”);
stream.println(“abc”);
stream.println(“abc”);
stream.println(“abc”);
stream.write(“welcome”.getBytes());

stream.close();

PrintStream ps = new PrintStream(“d.txt”, “GBK”);
ps.write(“中文汉字”.getBytes());//这个写进去，用的是IDE 默认的编码
ps.println(“又是一个中文汉字”); //这个写进去，用的是你指定的编码

//PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter pw = new PrintWriter(new FileOutputStream(“cc.txt”), true);
// pw.write(“abc”);
// 如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作
pw.println(“abc”);
pw.flush();
pw.close();

随机访问流概述（指针，能设置可读可写）
rw可读可写
r可读
w可写
//RandomAccessFile概述 最大特点 能读能写
//RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
//支持对随机访问文件的读取和写入。
//
//RandomAccessFile的父类是Object, 这个流对象可以用来读取数据也可以用来写数据.可以操作任意数据类型的数据.
// writeData();
RandomAccessFile raf = new RandomAccessFile(“a.txt”, “rw”);
boolean b = raf.readBoolean();
int i = raf.readInt();
String s = raf.readUTF();
System.out.println(b);
System.out.println(i);
System.out.println(s);
System.out.println(raf.getFilePointer()); //获取文件指针目前处于的位置
//可以移动文件指针
System.out.println("---------------------");
raf.seek(0);//可以设置文件指针的位置
b = raf.readBoolean();
i = raf.readInt();
s = raf.readUTF();
System.out.println(b);
System.out.println(i);
System.out.println(s);

序列化反序列化流

点上面再找下面这个

序列化流和反序列化流，能够读写对象
所谓的序列化：就是把对象通过流的方式存储到文件中.注意：此对象 要重写Serializable 接口才能被序列化
反序列化：就是把文件中存储的对象以流的方式还原成对象
序列化流:
ObjectOutputStream
反序列化流:
ObjectInputStream

顺序流

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，
直到到达包含的最后一个输入流的文件末尾为止。
SequenceInputStream(InputStream s1, InputStream s2)
通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。

多个文件合并到一起
Enumeration是Vector中特有的迭代器
SequenceInputStream(Enumeration < ? extends InputStream > e)
通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。