从接收输入值说起
在日常的开发应用中，有时候需要直接接收外部设备如键盘等的输入值，而对于这种数据的接收方式，我们一般有三种方法：字节流读取，字符流读取，Scanner 工具类读取。
字节流读取
直接看一个例子：
public class Demo01SystemIn {
public static void main(String[] args) throws IOException {
int a = System.in.read();
System.out.println(a);
char c = 'a';
System.out.println((int) c);
}
}
运行程序之后，会被 read 方法阻塞，这时候在控制台输入一个字符 a，那么上面的程序两句话都会输出 97，这个没问题，因为小写字母 a 对应的就是 97，那么假如我们输入一个中文会出现什么结果呢？
把上面示例中的 a 修改为 中，然后运行程序，在控制台同样输入 中，则会得到 228 和 20013，这就说明我们控制台输入的 中 并没有全部读取，原因就是 read 只能读取 1 个字节，为了进一步验证结论，我们将上面的例子进行改写：
public class Demo01SystemIn {
public static void main(String[] args) throws IOException {
char a = (char) System.in.read();//读取一个字节
System.out.println(a);
char c = '中';
System.out.println(c);
}
}
运行之后得到如下结果：
可以看到，第一个输出乱码了，因为 System.in.read() 一次只能读取一个字节，而中文在 utf-8 编码下占用了 3 个字节。正因为 read 方法一次只能读取一个字节，所以其范围只能在 -1~255 之间，-1 表示已经读取到了结尾。
那么如果想要完整的读取中文应该怎么办呢？
字符流读取
我们先看下面一个例子：
public class Demo01SystemIn {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader1 = new InputStreamReader(System.in);
int b = inputStreamReader1.read();//只能读一个字符
System.out.println(b);
InputStreamReader inputStreamReader2 = new InputStreamReader(System.in);
char[] chars = new char[2];
int c = inputStreamReader2.read(chars);//读入到指定char数组，返回当前读取到的字符数
System.out.println("读取的字符数为：" + c);
System.out.println(chars[0]);
System.out.println(chars[1]);
}
}
运行之后，输出结果如下所示：
这个时候我们已经能完成的读取到一个字符了，当然，有时候为了优化，我们需要使用 BufferedReader 进行进一步的包装：
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
这种方式虽然解决了读取中文会乱码问题，但是使用起来也不是很方便，所以一般读取键盘输入信息我们都会采用 Scnner 来读取。
Scanner 读取
Scanner 实际上还是对 System.in 进行了封装，并提供了一系列方法来读取不同的字符类型，比如 nextInt，nextFloat，以及 next 等。
public class Demo02Scnner {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()){
System.out.println(scanner.nextInt());
}
}
}
什么是 IO 流
流是一种抽象概念，它代表了数据的无结构化传输（摘自百度百科）。IO 流对应的就是 InPut 和 Output，也就是输入和输出。输入和输出这个概念是针对于应用程序而言，比如当前程序中需要读取文件中的内容，那么这就是输入，而如果需要将应用程序本身的数据发送到其他应用，就对应了输出。
字节流和字符流
根据流的处理方式又可以将流可以分为两种类型：字节流和字符流。
字节流
字节流读取的基本单位为字节，采用的是 ASCII 编码，通常用来处理二进制数据，其顶层抽象类为 InputStream 和 OutputStream，比如上面示例中的 System.in 实际上就是获取到了一个 InputStream 类。
Java 中的流家族非常庞大，提供了非常多的具有不同功能的流，在实际应用中我们可以选择不同的组合达到目的。
字节输入流
下图为字节输入流家族关系示意图：
从上图可以看出这些结构非常清晰，首先是一个最顶层的接口，其次就是一些不同功能的基础流，比如我们最常用的 FileInputStream 就是用来读取文件的，这其中有一个 FilterInputStream 流，这个流主要是用来扩展基础流功能，其本身只是简单的覆盖了父类 InputStream 中的所有方法，并没有做什么特殊处理，真正的功能扩展需要依赖于其众多的子类，比如最常用的 BufferedInputStream 提供了数据的缓冲，从而提升读取流的效率，而 DataInputStream 是可以用来处理二进制数据等等。
通过这些众多不同功能的流来组合，可以灵活的读取我们需要的数据。比如当我们需要读取一个二进制文件，那么就需要使用 DataInputStream，而 DataInputStream 本身不具备直接读取文件内容的功能，所以需要结合 FileInputStream：
FileInputStream fin = new FileInputStream("E:\\test.txt");
DataInputStream din = new DataInputStream(fin);
System.out.println(din.readInt());
同时，如果我们想要使用缓冲机制，又可以进一步组装 BufferedInputStream：
FileInputStream fin = new FileInputStream("E:\\test.txt");
DataInputStream din = new DataInputStream(new BufferedInputStream(fin));
System.out.println(din.readInt());
还有一种流比较有意思，那就是 PushbackInputStream，这个流可以将读出来的数据重新推回到流中：
public class Demo03 {
public static void main(String[] args) throws IOException {
FileInputStream fin = new FileInputStream("E:\\test.txt");//文档内存储 abcd
PushbackInputStream pin = new PushbackInputStream(new BufferedInputStream(fin));
int a = pin.read();//读取到a
System.out.println(a);
if (a != 'b'){
pin.unread(a);//将 a 推回流中
}
System.out.println(pin.read());//再次读取到 a
System.out.println(pin.read());//读取到 b
System.out.println(pin.read());// 读取到 c
}
}
字节输出流
下图为字节输出流家族关系示意图：
这个结构和输入流的结构基本类似，同样的我们也可以通过组合来实现不同的输出。
比如普通的输出文件，可以使用 FileOutputStream 流：
FileOutputStream fout = new FileOutputStream("E:\\test2.txt");
fout.write(1);
fout.write(2);
如果想要输出二进制格式，那么就可以组合 DataOutputStream 流：
FileOutputStream fout = new FileOutputStream("E:\\test2.txt");
DataOutputStream dout = new DataOutputStream(fout);
dout.write(9);
dout.write(10);
缓冲流的原理
IO 操作是一个比较耗时的操作，而字节流的 read 方法一次只能返回一个字节，那么当我们需要读取多个字节时就会出现每次读取都要进行一次 IO 操作，而缓冲流内部定义了一个大小为 8192 的 byte 数组，当我们使用了缓冲流时，读取数据的时候则会一次性最多读取 8192 个字节放到内存，然后一个个依次返回，这样就大大减少了 IO 次数；同样的，写数据时，缓冲流会将数据先写到内存，当我们写完需要写的数据时再一次性刷新到指定位置，如磁盘等。
字符流
字符流读取的基本单位为字符，采用的是 Unicode 编码，其 read 方法返回的是一个 Unicode 码元（0~65535）。
字符流通常用来处理文本数据，其顶层抽象类为 Reader 和 Write，比如文中最开始的示例中的 InputStreamReader 就是继承自 Reader 类。
字符输入流
下图为字符输入流家族关系示意图：
上图可以看出，除顶层 Reader 类之外，字符流也提供了一些基本的字符流来处理文本数据，比如我们需要从文本读取内容：
public class Demo05Reader {
public static void main(String[] args) throws Exception {
//字节流
FileInputStream fin = new FileInputStream("E:\\test.txt");//文本内容为“双子孤狼”
System.out.println(fin.read());//372
//字符流
InputStreamReader ir = new InputStreamReader(new FileInputStream("E:\\test.txt"));//文本内容为“双子孤狼”
System.out.println(ir.read());//21452
char s = '双';
System.out.println((int)s);//21452
}
}
输出之后可以很明显看出区别，字节流一次读入一个字节，而字符流一次读入一个字符。
当然，我们也可以采用自由组合的方式来更灵活的进行字符读取，比如我们结合 BufferedReader 来读取一整行数据：
public class Demo05Reader {
public static void main(String[] args) throws Exception {
InputStreamReader ir = new InputStreamReader(new FileInputStream("E:\\test.txt"));//文本内容为“双子孤狼”
BufferedReader br = new BufferedReader(ir);
String s;
while (null != (s = br.readLine())){
System.out.println(s);//输出双子孤狼
}
}
}
字符输出流
下图为字符输出流家族关系示意图：
文本输出，我们用的最多的就是 PrintWriter，这个类我想绝大部分朋友都使用过：
public class Demo06Writer {
public static void main(String[] args) throws Exception{
PrintWriter printWriter = new PrintWriter("E:\\test3.txt");
printWriter.write("双子孤狼");
printWriter.flush();
}
}
这里和字节流的区别就是写完之后需要手动调用 flush 方法，否则数据就会丢失，并不会写到文件中。
为什么字符流需要 flush，而字节流不需要
字节流不需要 flush 操作是因为字节流直接操作的是字节，中途不需要做任何转换，所以直接就可以操作文件，而字符流，说到底，其底层还是字节流，但是字符流帮我们将字节转换成了字符，这个转换需要依赖字符表，所以就需要在字符和字节完成转换之后通过 flush 操作刷到磁盘中。
需要注意的是，字节输出流最顶层类 OutputStream 中也提供了 flush 方法，但是它是一个空的方法，如果有子类有需要，也可以实现 flush 方法。
RandomAccessFile
RandomAccessFile 是一个随机访问文件类，其可以在文件中的任意位置查找或者写入数据。
public class Demo07RandomAccessFile {
public static void main(String[] args) throws Exception {
//文档内容为 lonely wolf
RandomAccessFile inOut = new RandomAccessFile(new File("E:\\test.txt"),"rw");
System.out.println("当前指针在：" + inOut.getFilePointer());//默认在0
System.out.println((char) inOut.read());//读到 l
System.out.println("当前指针在：" + inOut.getFilePointer());
inOut.seek(7L);//指针跳转到7的位置
System.out.println((char) inOut.read());//读到 w
inOut.seek(7);//跳回到 7
inOut.write(new byte[]{'c','h','i','n','a'});//写入 china,此时 wolf被覆盖
inOut.seek(7);//继续跳回到 7
System.out.println((char) inOut.read());//此时因为 wolf 被 china覆盖，所以读到 c
}
}
根据上面的示例中的输出结果，可以看到 RandomAccessFile 类可以随机指定指针，并随机进行读写，功能非常强大。
另外需要说明的是，构造 RandomAccessFile 时需要传入一个模式，模式主要有 4 种：
- r：只读模式。此时调用任何 write 相关方法，会抛出 IOException。
- rw：读写模式。支持读写，如果文件不存在，则会创建。
- rws：读写模式。每当进行写操作，会将内容或者元数据同步刷新到磁盘。
- rwd：读写模式。每当进行写操作时，会将变动的内容用同步刷新到磁盘。
以上就是Java字节流和字符流及IO流的总结的详细内容，更多关于Java字节流和字符流的资料请关注脚本之家其它相关文章！