共计 7411 个字符，预计需要花费 19 分钟才能阅读完成。
关注我不迷路，叮~
1. 基本概念
IO：Java 对数据的操作是通过流的形式，IO 流用来解决设施之间的数据传输，上传文件和下载文件，Java 用于操作流的对象都在 IO 包中。
2.IO 流的分类
图示：（次要 IO 流）
3. 字节流
（1）. 字节流基类
1）.InputStream
InputStream：字节输出流基类，抽象类是示意字节输出流的所有类的超类。
罕用办法：// 从输出流中读取数据的下一个字节
abstract int read()
// 从输出流中读取肯定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b)
// 将输出流中最多 len 个数据字节读入 byte 数组
int read(byte[] b, int off, int len)
// 跳过和抛弃此输出流中数据的 n 个字节
long skip(long n)
// 敞开此输出流并开释与该流关联的所有系统资源
void close()
2）.OutputStream
OutputStream：字节输入流基类，抽象类是示意输入字节流的所有类的超类。
罕用办法：// 将 b.length 个字节从指定的 byte 数组写入此输入流
void write(byte[] b)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输入流
void write(byte[] b, int off, int len)
// 将指定的字节写入此输入流
abstract void write(int b)
// 敞开此输入流并开释与此流无关的所有系统资源
void close()
// 刷新此输入流并强制写出所有缓冲的输入字节
void flush()
（2）. 字节文件操作流
1）.FileInputStream
FileInputStream：字节文件输出流，从文件系统中的某个文件中取得输出字节，用于读取诸如图像数据之类的原始字节流。
构造方法：// 通过关上一个到理论文件的连贯来创立一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定
FileInputStream(File file)
// 通过关上一个到理论文件的连贯来创立一个 FileInputStream，该文件通过文件系统中的门路 name 指定
FileInputStream(String name)
罕用办法：笼罩和重写了父类的的罕用办法。 // 读取 f 盘下该文件 f://hell/test.txt
// 构造方法 1
InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
int i = 0;
// 一次读取一个字节
while ((i = inputStream.read()) != -1) {// System.out.print(i + " ");// 65 66 67 68
// 为什么会输入 65 66 67 68？因为字符在底层存储的时候就是存储的数值。即字符对应的 ASCII 码。System.out.print((char) i + " ");// A B C D
}
// 敞开 IO 流
inputStream.close();
// 读取 f 盘下该文件 f://hell/test.txt
// 构造方法 2
InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
// 字节数组
byte[] b = new byte[2];
int i2 = 0;
// 一次读取一个字节数组
while ((i2 = inputStream2.read(b)) != -1) {System.out.print(new String(b, 0, i2) + " ");// AB CD
}
// 敞开 IO 流
inputStream2.close();
注：一次读取一个字节数组，进步了操作效率,IO 流应用结束肯定要敞开。
2）.FileOutputStream
FileOutputStream：字节文件输入流是用于将数据写入到 File，从程序中写入到其余地位。
构造方法：// 创立一个向指定 File 对象示意的文件中写入数据的文件输入流
FileOutputStream(File file)
// 创立一个向指定 File 对象示意的文件中写入数据的文件输入流
FileOutputStream(File file, boolean append)
// 创立一个向具备指定名称的文件中写入数据的输入文件流
FileOutputStream(String name)
// 创立一个向具备指定 name 的文件中写入数据的输入文件流
FileOutputStream(String name, boolean append)
罕用办法：笼罩和重写了父类的的罕用办法。 OutputStream outputStream = new FileOutputStream(new File("test.txt"));
// 写出数据
outputStream.write("ABCD".getBytes());
// 敞开 IO 流
outputStream.close();
// 内容追加写入
OutputStream outputStream2 = new FileOutputStream("test.txt", true);
// 输入换行符
outputStream2.write("\r\n".getBytes());
// 输入追加内容
outputStream2.write("hello".getBytes());
// 敞开 IO 流
outputStream2.close();
注；输入的目的地文件不存在，则会主动创立，不指定盘符的话，默认创立在我的项目目录下; 输入换行符时肯定要写 \r\n 不能只写 \n, 因为不同文本编辑器对换行符的辨认存在差异性。
（3）. 字节缓冲流（高效流）
1）.BufferedInputStream
BufferedInputStream：字节缓冲输出流，进步了读取效率。
构造方法：// 创立一个 BufferedInputStream 并保留其参数，即输出流 in，以便未来应用。BufferedInputStream(InputStream in)
// 创立具备指定缓冲区大小的 BufferedInputStream 并保留其参数，即输出流 in 以便未来应用
BufferedInputStream(InputStream in, int size)
InputStream in = new FileInputStream("test.txt");
// 字节缓存流
BufferedInputStream bis = new BufferedInputStream(in);
byte[] bs = new byte[20];
int len = 0;
while ((len = bis.read(bs)) != -1) {System.out.print(new String(bs, 0, len));
// ABCD
// hello
}
// 敞开流
bis.close();
2）.BufferedOutputStream
BufferedOutputStream：字节缓冲输入流，进步了写出效率。
构造方法：// 创立一个新的缓冲输入流，以将数据写入指定的底层输入流
BufferedOutputStream(OutputStream out)
// 创立一个新的缓冲输入流，以将具备指定缓冲区大小的数据写入指定的底层输入流
BufferedOutputStream(OutputStream out, int size)
罕用办法：// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输入流
void write(byte[] b, int off, int len)
// 将指定的字节写入此缓冲的输入流
void write(int b)
// 刷新此缓冲的输入流
void flush()
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
// 输入换行符
bos.write("\r\n".getBytes());
// 输入内容
bos.write("Hello Android".getBytes());
// 刷新此缓冲的输入流
bos.flush();
// 敞开流
bos.close();
4. 字符流
（1）. 字符流基类
1）.Reader
Reader: 读取字符流的抽象类.
罕用办法：// 读取单个字符
int read()
// 将字符读入数组
int read(char[] cbuf)
// 将字符读入数组的某一部分
abstract int read(char[] cbuf, int off, int len)
// 跳过字符
long skip(long n)
// 敞开该流并开释与之关联的所有资源
abstract void close()
2）.Writer
Writer: 写入字符流的抽象类.
罕用办法：// 写入字符数组
void write(char[] cbuf)
// 写入字符数组的某一部分
abstract void write(char[] cbuf, int off, int len)
// 写入单个字符
void write(int c)
// 写入字符串
void write(String str)
// 写入字符串的某一部分
void write(String str, int off, int len)
// 将指定字符增加到此 writer
Writer append(char c)
// 将指定字符序列增加到此 writer
Writer append(CharSequence csq)
// 将指定字符序列的子序列增加到此 writer.Appendable
Writer append(CharSequence csq, int start, int end)
// 敞开此流，但要先刷新它
abstract void close()
// 刷新该流的缓冲
abstract void flush()
（2）. 字符转换流
1）.InputStreamReader
InputStreamReader：字节流转字符流，它应用的字符集能够由名称指定或显式给定，否则将承受平台默认的字符集。
构造方法：// 创立一个应用默认字符集的 InputStreamReader
InputStreamReader(InputStream in)
// 创立应用给定字符集的 InputStreamReader
InputStreamReader(InputStream in, Charset cs)
// 创立应用给定字符集解码器的 InputStreamReader
InputStreamReader(InputStream in, CharsetDecoder dec)
// 创立应用指定字符集的 InputStreamReader
InputStreamReader(InputStream in, String charsetName)
特有办法：// 返回此流应用的字符编码的名称
String getEncoding()
// 应用默认编码
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
int len;
while ((len = reader.read()) != -1) {System.out.print((char) len);// 爱生存，爱 Android
}
reader.close();
// 指定编码
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");
int len;
while ((len = reader.read()) != -1) {System.out.print((char) len);//????????Android
}
reader.close();
注：Eclipse 默认应用 GBK 编码,test.txt 文件所以是 GBK 编码，当指定 utf- 8 编码时所以会乱码。
2）.OutputStreamWriter
OutputStreamWriter：字节流转字符流。
构造方法：// 创立应用默认字符编码的 OutputStreamWriter
OutputStreamWriter(OutputStream out)
// 创立应用给定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs)
// 创立应用给定字符集编码器的 OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
// 创立应用指定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName)
特有办法：// 返回此流应用的字符编码的名称
String getEncoding()
（3）. 字符缓冲流（高效流）
1）.BufferedReader
BufferedReader：字符缓冲流，从字符输出流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
构造方法：// 创立一个应用默认大小输出缓冲区的缓冲字符输出流
BufferedReader(Reader in)
// 创立一个应用指定大小输出缓冲区的缓冲字符输出流
BufferedReader(Reader in, int sz)
特有办法：// 读取一个文本行
String readLine()
// 生成字符缓冲流对象
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
String str;
// 一次性读取一行
while ((str = reader.readLine()) != null) {System.out.println(str);// 爱生存，爱 Android
}
// 敞开流
reader.close();
2）.BufferedWriter
BufferedWriter：字符缓冲流，将文本写入字符输入流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
构造方法：// 创立一个应用默认大小输入缓冲区的缓冲字符输入流
BufferedWriter(Writer out)
// 创立一个应用给定大小输入缓冲区的新缓冲字符输入流
BufferedWriter(Writer out, int sz)
特有办法：// 写入一个行分隔符
void newLine()
（4）.FileReader、FileWriter
FileReader：InputStreamReader 类的间接子类，用来读取字符文件的便捷类，应用默认字符编码。FileWriter：OutputStreamWriter 类的间接子类，用来写入字符文件的便捷类，应用默认字符编码。5. 高效流效率比对
读取 f 盘下的一个视频文件到我的项目中：文件大小 29.5 MB
读取形式一：
FileInputStream inputStream = new FileInputStream("f:// 滑板 //HEEL_FLIP.mp4");
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
int len;
// 开始工夫
long begin = System.currentTimeMillis();
// 一次读取一个字节
while ((len = inputStream.read()) != -1) {outputStream.write(len);
}
// 用时毫秒
System.out.println(System.currentTimeMillis() - begin);// 213195
// 敞开流开释资源
inputStream.close();
outputStream.close();
读取形式二：
FileInputStream inputStream = new FileInputStream("f:// 滑板 //HEEL_FLIP.mp4");
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
int len;
byte[] bs = new byte[1024];
// 开始工夫
long begin = System.currentTimeMillis();
// 一次读取一个字节数组
while ((len = inputStream.read(bs)) != -1) {outputStream.write(bs, 0, len);
}
// 用时毫秒
System.out.println(System.currentTimeMillis() - begin);// 281
inputStream.close();
outputStream.close();
读取形式三：
FileInputStream inputStream = new FileInputStream("f:// 滑板 //HEEL_FLIP.mp4");
BufferedInputStream bis = new BufferedInputStream(inputStream);
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
BufferedOutputStream bos = new BufferedOutputStream(outputStream);
int len;
byte[] bs = new byte[1024];
// 开始工夫
long begin = System.currentTimeMillis();
while ((len = bis.read(bs)) != -1) {bos.write(bs, 0, len);
}
// 用时毫秒
System.out.println(System.currentTimeMillis() - begin);// 78
bis.close();
bos.close();
注：由此能够看出高效缓冲流读写速度是十分快的，倡议应用。
对于更多的 Java 基础知识的知识点我已整顿成一个 pdf, 这样，不便大家浏览和参考，戳我支付！！！也能够关注我后续文章的推送喔~
正文完