字节流基类：InputStream(读) OutputStream (写) ? 字符流基类：Reader (读) Writer(写)
（OutputStream 的子类，OutputStream 为抽象类，）
A、创建字节输出流对象
B、调用write()方法，写入数据
public void write(int b):写一个字节
public void write(byte[] b):写一个字节数组
public void write(byte[] b,int off,int len):写一个字节数组的一部分，从off开始，长度为len
C、释放资源
1.FileOutputStream(File file)
2.FileOutputStream(String name)
3.FileOutputStream(String name, true); 用于追加写入数据，否则会一直从头写入
4.FileOutputStream(File file, true);
File file = new File("D:\\a.txt");
?
//写入数据
FileOutputStream fileOutputStream = new FileOutputStream(file);
fileOutputStream.write("hello,I/O".getBytes());
//fileOutputStream.write(97); 写入的值为a，底层二进制数据 -- 通过记事本打开 -- 找97对应的字符值 -- a
?
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源
fileOutputStream.close();
思考：
FileOutputStream fileOutputStream = new FileOutputStream(file);
创建字节输出流对象做了几件事：
A：调用系统功能去创建文件
B：创建fileOutputStream对象
C：把fileOutputStream对象指向这个文件
为什么一定要close()?
A:让流对象变成垃圾，可以被垃圾回收器回收；
B:通知系统释放跟该文件相关的资源
如何实现数据的换行?
写入换行符号；
不同的系统针对不同的换行符号识别是不一样的（高级记事本可自动识别）：
windows:\r\n
linux:\n
Mac:\r
File file = new File("D:\\a.txt");
?
FileOutputStream fos = new FileOutputStream(file);
?
// 写数据
for (int x = 0; x < 10; x++) {
fos.write(("hello" + x).getBytes());
fos.write("\r\n".getBytes());
}
fos.close();
如何实现追加写入？
用构造方法带第二个参数是true的情况即可
File file = new File("D:\\a.txt");
//追加写入数据
FileOutputStream fos = new FileOutputStream(file, true);
?
// 写数据
for (int x = 0; x < 10; x++) {
fos.write(("hello" + x).getBytes());
fos.write("\r\n".getBytes());
}
?
fos.close();
字节流读取数据
A:创建字节输入流对象
B:调用read()方法读取数据，并把数据显示在控制台
C:释放资源
?
FileInputStream(File file)
FileInputStream(String name)
A: int read() 一次读取下一个数据字节；如果已到达文件末尾，则返回 -1。
B: int read (byte[ ] b ) 一次读取一个字节数组，比read() 快，返回值其实是实际读取的字节个数；数组中元素存储的是字母对应的数值
一次读取一个字节
FileInputStream fis = new FileInputStream("fis.txt");
?
int read = fis.read();
System.out.println(read); //读取一个字节 注意：读取的如果是字母，则会被转换为数字，如a -->97; 换行符也会被读取，如 \n 占一个字节
System.out.println((char)read); //转换数据类型就可以变为字母
?
//循环读取所有数据
int by = 0;
// 读取，赋值，判断
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
?
fis.close();
一次读取一个字节数组
FileInputStream fis = new FileInputStream("fis.txt");
?
// 数组的长度一般是1024或者1024的整数倍
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
fis.close();
// 封装数据源
FileInputStream fis = new FileInputStream("a.txt");
// 封装目的地
FileOutputStream fos = new FileOutputStream("b.txt");
?
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
?
// 释放资源(先关谁都行)
fos.close();
fis.close();
在计算机中中文的存储分两个字节：
第一个字节肯定是负数。
第二个字节常见的是负数，可能有正数。但是没影响。
//String s = "abcde";
// // [97, 98, 99, 100, 101]
?
String s = "我爱你中国";
// [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
?
byte[] bys = s.getBytes();
System.out.println(Arrays.toString(bys));
写数据：BufferedOutputStream 缓冲输出流
读数据：BufferedInputStream 缓冲输入流
构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。
为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。
为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。
缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。
这样可以减少访问硬盘的次数,提高传输效率。
BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。
BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 简单写法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("bos.txt"));
?
// 写数据
bos.write("hello".getBytes());
?
// 释放资源
bos.close();
思考：为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
两种方式
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
//第一种
// 读取数据
// int by = 0;
// while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
// System.out.println("---------");
?
//第二种
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
?
// 释放资源
bis.close();
注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。如果都使用，也只会读取一个，因为read方法已执行到数据末尾。
字符流 = 字节流+编码表
构造方法 不设置则为使用平台的默认字符集解码，windows为GBK
String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
方法：不设置则为使用平台的默认字符集解码, windows为GBK
byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
编码:把看得懂的变成看不懂的：String -- byte[]
解码:把看不懂的变成看得懂的：byte[] -- String
需要保证 编码和解码的格式是一样的，不设置则为使用平台的默认字符集解码
String s = "你好";
?
// String -- byte[]
byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
// byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
// byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
System.out.println(Arrays.toString(bys));
?
// byte[] -- String
String ss = new String(bys); // 你好
// String ss = new String(bys, "GBK"); // 你好
// String ss = new String(bys, "UTF-8"); // ???
System.out.println(ss);
OutputStreamWriter 和 InputStreamReader
OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
InputStreamReader(InputStream is):用默认的编码读取数据
InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
字符流 = 字节流 +编码表。
编码
// 创建对象
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
// "osw.txt")); // 默认GBK
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
// "osw.txt"), "GBK"); // 指定GBK
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"osw.txt"), "UTF-8"); // 指定UTF-8
// 写数据
osw.write("中国");
?
// 释放资源
osw.close();
解码
// 创建对象
// InputStreamReader isr = new InputStreamReader(new FileInputStream(
// "osw.txt"));
?
// InputStreamReader isr = new InputStreamReader(new FileInputStream(
// "osw.txt"), "GBK");
?
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"osw.txt"), "UTF-8");
?
// 读取数据
// 一次读取一个字符
int ch = 0;
while ((ch = isr.read()) != -1) {
System.out.print((char) ch);
}
?
// 释放资源
isr.close();
方法
public void write(int c):写一个字符
public void write(char[] cbuf):写一个字符数组
public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
public void write(String str):写一个字符串
public void write(String str,int off,int len):写一个字符串的一部分
// 创建对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"osw2.txt"));
?
// 写数据
public void write(int c);//写一个字符
osw.write(‘a‘);
osw.write(97);
// 为什么数据没有进去呢?
// 原因是：字符 = 2字节
// 文件中数据存储的基本单位是字节。
//如果没有关闭流close（），则需要刷新缓冲区
osw.flush();//也可不写
// 释放资源
osw.close();
面试题：close()和flush()的区别?
A:close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
B:flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。
方法
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组
// 创建对象
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"StringDemo.java"));
?
// 一次读取一个字符
// int ch = 0;
// while ((ch = isr.read()) != -1) {
// System.out.print((char) ch);
// }
?
// 一次读取一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = isr.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
?
// 释放资源
isr.close();
// 封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"a.txt"));
// 封装目的地
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"b.txt"));
?
// 读写数据
// 方式1
// int ch = 0;
// while ((ch = isr.read()) != -1) {
// osw.write(ch);
// }
?
// 方式2
char[] chs = new char[1024];
int len = 0;
while ((len = isr.read(chs)) != -1) {
osw.write(chs, 0, len);
// osw.flush();
}
?
// 释放资源
osw.close();
isr.close();
由于我们常见的操作都是使用本地默认编码，所以，不用指定编码。而转换流的名称有点长，所以，Java就提供了其子类供我们使用。
FileWriter 的编码是根据你的运行平台来获取编码
OutputStreamWriter = FileOutputStream + 编码表
FileWriter = FileOutputStream + 编码表
InputStreamReader = FileInputStream + 编码表
FileReader = FileInputStream + 编码表
// 封装数据源
FileReader fr = new FileReader("a.txt");
// 封装目的地
FileWriter fw = new FileWriter("b.txt");
?
// 一次一个字符
// int ch = 0;
// while ((ch = fr.read()) != -1) {
// fw.write(ch);
// }
?
// 一次一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = fr.read(chs)) != -1) {
fw.write(chs, 0, len);
fw.flush();
}
?
// 释放资源
fw.close();
fr.close();
字符流为了高效读写，也提供了对应的字符缓冲流。
BufferedWriter:字符缓冲输出流
BufferedReader:字符缓冲输入流
BufferedWriter:字符缓冲输出流
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
// BufferedWriter(Writer out)
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
// new FileOutputStream("bw.txt")));
?
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
?
bw.write("hello");
bw.write("world");
bw.write("java");
bw.flush();
?
bw.close();
BufferedReader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
// 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
?
// 方式1
// int ch = 0;
// while ((ch = br.read()) != -1) {
// System.out.print((char) ch);
// }
?
// 方式2
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
?
// 释放资源
br.close();
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
?
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
bw.write(chs, 0, len);
bw.flush();
}
?
// 释放资源
bw.close();
br.close();
BufferedWriter:
public void newLine():根据系统来决定换行符
BufferedReader:
public String readLine()：一次读取一行数据
包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
无法自己换行，可以配合System.out.println（）使用
newLine()
// 创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
for (int x = 0; x < 10; x++) {
bw.write("hello" + x);
// bw.write("\r\n");
bw.newLine();
bw.flush();
}
bw.close();
readLine()
// 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
//释放资源
br.close();
复制文本文件
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
?
// 读写数据
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
?
// 释放资源
bw.close();
br.close();
原文：https://www.cnblogs.com/wcare/p/14526142.html