Java中的IO操作和缓冲区
一、简述
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
根据数据的单位划分: 字节流和字符流。
Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。
本文主要介绍Java中的字符流和字节流，以及缓冲区的区别
二、IO流的介绍
什么是流
Java中的流是对字节序列的抽象，我们可以想象有一个水管，只不过现在流动在水管中的不再是水，而是字节序列。和水流一样，Java中的流也具有一个“流动的方向”，通常可以从中读入一个字节序列的对象被称为输入流；能够向其写入一个字节序列的对象被称为输出流。
输入输出流的作用范围
三、Java中的字节流和字符流
字节流
Java中的字节流处理的最基本单位为单个字节，它通常用来处理二进制数据。Java中最基本的两个字节流类是InputStream和OutputStream，它们分别代表了组基本的输入字节流和输出字节流。InputStream类与OutputStream类均为抽象类，我们在实际使用中通常使用Java类库中提供的它们的一系列子类。
字符流
Java中的字符流处理的最基本的单元是Unicode码元（大小统一为2字节），它通常用来处理文本数据。所谓Unicode码元，也就是一个Unicode代码单元，范围是0x0000~0xFFFF。在以上范围内的每个数字都与一个字符相对应，Java中的String类型默认就把字符以Unicode规则编码而后存储在内存中。然而与存储在内存中不同，存储在磁盘上的数据通常有着各种各样的编码方式。使用不同的编码方式，相同的字符会有不同的二进制表示。
Java中最基本的两个字符流类是Reader和Writer。
二者的联系
Java提供了以下两种IO类型的相互转化
InputStreamReader(字节到字符)和 OutputStreamReader(字符到字节):
1.InputStreamReader
从字节流到字符流的桥梁：它读入字节，并根据指定的编码方式，将之转换为字符流。
使用的编码方式可能由名称指定，或平台可接受的缺省编码方式
InputStreamReader的read()方法之一的每次调用，可能促使从基本字节输入流中读取一个或多个字节。
2.OutputStreamWriter
将多个字符写入到一个输出流，根据指定的字符编码将多个字符转换为字节
每个 OutputStreamWriter 合并它自己的 CharToByteConverter, 因而是从字符流到字节流的桥梁。
字符流=字节流+Unicode编码
字节流变为字符流=基本单位从一个字节变为两个字节（Unicode编码）
字节流和字符流的区别
读取单位不同
- 字节流：用于读取一个一个的数据字节（8位），每8位当成一个单元
- 字符流：用于读取一个一个的数据字符（16位），每16位当成一个单元
执行效率不同
从执行效率来说，字符流相对于字节流的速度是要快的。因为字符流每次处理是可以处理一个缓冲区的，而字节只能一个一个字节的处理。
使用对象不同
1. 字节流通常用于处理二进制数据，实际上它可以**处理任意类型**的数据，但它不支持直接写入或读取Unicode码元；
2. 字符流通常处理文本数据，它支持写入及读取**Unicode码元**。
缓冲区的使用
- 字节流默认不使用缓冲区；
- 字符流使用缓冲区。
四、效率测试
代码测试
输入测试
package IOOperation;
import java.io.*;
/**
* @Description 输入流的测试
* @Author 林泽鸿
* @Date 2020/5/31 11:27
*/
public class InputTest {
/**
* 用于输入的对象，大小为2.58MB
*/
public static final File inputFile = new File("E:\\RDC\\学习资料\\2.pdf");
// 字节流
public void bytes() {
try {
System.out.println("1.字节流输入");
// 新建文件命名
// 创建输入输出流对象
long s1 = System.currentTimeMillis();// 测试开始，计时
FileInputStream fileInputStream = new FileInputStream(inputFile);
// 读写数据
// 读写数据
while (fileInputStream.read() != -1) {
}
fileInputStream.close();
long s2 = System.currentTimeMillis();// 测试结束，计时
System.out.println("输入文件耗时：" + (s2 - s1) + "ms");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
//字符流
public void chars() {
try {
System.out.println("2.字符流输入");
// 新建文件命名
long s1 = System.currentTimeMillis();// 测试开始，计时
// 创建输入输出流对象
FileReader fileReader = new FileReader(inputFile);
// 读写数据
while (fileReader.read() != -1) {
}
fileReader.close();
long s2 = System.currentTimeMillis();// 测试结束，计时
System.out.println("输入文件耗时：" + (s2 - s1) + "ms");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// 字节缓冲流
public void bytesBuffer() {
try {
System.out.println("3.字节缓冲流输入");
// 新建文件命名
long s1 = System.currentTimeMillis();// 测试开始，计时
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(inputFile));
// 创建输入输出流对象
// 读写数据
while (bufferedInputStream.read() != -1) {
}
bufferedInputStream.close();
long s2 = System.currentTimeMillis();// 测试结束，计时
System.out.println("输入文件耗时：" + (s2 - s1) + "ms");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// 字符缓冲流
public void charsBuffer() {
try {
System.out.println("4.字符缓冲流输入");
// 新建文件命名
long s1 = System.currentTimeMillis();// 测试开始，计时
// 创建输入输出流对象
BufferedReader bufferedReader = new BufferedReader(new FileReader(inputFile));
// 读写数据
while (bufferedReader.read() != -1) {
}
bufferedReader.close();
long s2 = System.currentTimeMillis();// 测试结束，计时
System.out.println("输入文件耗时：" + (s2 - s1) + "ms");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出测试
package IOOperation;
import java.io.*;
/**
* @Description 输出流的测试
* @Author 林泽鸿
* @Date 2020/5/31 11:28
*/
public class OutPutTest {
public static final String PATH =
"E:\\codingEnvironment\\GitRepository\\JAVA\\src\\fileCatalog\\";
int count = 1;
/**
* 用于输出的对象
*/
public static byte[] outputBytes = null;
public static char[] outputChars = null;
public static void before() {
StringBuilder stringBuilder = new StringBuilder("");
for (int i = 0; i < 300000; i++) {
stringBuilder.append("testtesttesttesttesttest");
}
outputBytes = stringBuilder.toString().getBytes();
outputChars = stringBuilder.toString().toCharArray();
}
// 字节流
public void bytes() {
try {
System.out.println("1.字节流输出");
// 新建文件命名
String name = PATH + "字节流输出文件.txt";
File file = new File(name);
// 创建输入输出流对象
FileOutputStream fos = new FileOutputStream(file);
// 读写数据
long s1 = System.currentTimeMillis();// 测试开始，计时
writeBytes(fos);
long s2 = System.currentTimeMillis();// 测试结束，计时
fos.close();
System.out.println("输出文件耗时：" + (s2 - s1) + "ms");
System.out.println("文件大小：" + file.length() / 1024 + "KB");
file.delete();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// 字节流
public void chars() {
try {
System.out.println("2.字符流输出");
// 新建文件命名
String name = PATH + "字符流输出文件.txt";
File file = new File(name);
// 创建输入输出流对象
FileWriter fileWriter = new FileWriter(file);
// 读写数据
long s1 = System.currentTimeMillis();// 测试开始，计时
writeChars(fileWriter);
long s2 = System.currentTimeMillis();// 测试结束，计时
fileWriter.close();
System.out.println("输出文件耗时：" + (s2 - s1) + "ms");
System.out.println("文件大小：" + file.length() / 1024 + "KB");
file.delete();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// 字节缓冲流
public void bytesBuffer() {
try {
System.out.println("3.字节缓冲流输出");
// 新建文件命名
String name = PATH + "字节缓冲流输出文件.txt";
File file = new File(name);
// 创建输入输出流对象
FileOutputStream fileOutputStream = new FileOutputStream(file);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
// 读写数据
long s1 = System.currentTimeMillis();// 测试开始，计时
writeBytes(bufferedOutputStream);
long s2 = System.currentTimeMillis();// 测试结束，计时
bufferedOutputStream.close();
System.out.println("输出文件耗时：" + (s2 - s1) + "ms");
System.out.println("文件大小：" + file.length() / 1024 + "KB");
file.delete();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// 字符缓冲流
public void charsBuffer() {
try {
System.out.println("4.字符缓冲流输出");
// 新建文件命名
String name = PATH + "字符缓冲流输出文件.txt";
File file = new File(name);
// 创建输入输出流对象
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
// 读写数据
long s1 = System.currentTimeMillis();// 测试开始，计时
for (int i = 0; i < count; i++) {
bufferedWriter.write(outputChars);
}
long s2 = System.currentTimeMillis();// 测试结束，计时
bufferedWriter.close();
System.out.println("输出文件耗时：" + (s2 - s1) + "ms");
System.out.println("文件大小：" + file.length() / 1024 + "KB");
file.delete();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 字节输出
*/
private void writeBytes(OutputStream fos) throws IOException {
for (int i = 0; i < count; i++) {
for (int j = 0; j < outputBytes.length; j++) {
fos.write(outputBytes[j]);
}
}
}
/**
* 字符输出
*/
private void writeChars(Writer writer) throws IOException {
for (int i = 0; i < count; i++) {
for (int j = 0; j < outputChars.length; j++) {
writer.write(outputChars[j]);
}
}
}
}
主测试类
package IOOperation;
/**
* @Description Java中IO效率的比较
* @Author 林泽鸿
* @Date 2020/5/31 10:48
*/
public class Main {
public static void main(String[] args) {
OutPutTest.before();
InputTest inputTest = new InputTest();
System.out.println("========================");
System.out.println("测试输入流（文件大小：2.58MB）");
System.out.println("========================");
inputTest.bytes();
inputTest.chars();
inputTest.bytesBuffer();
inputTest.charsBuffer();
OutPutTest outPutTest = new OutPutTest();
System.out.println("========================");
System.out.println("测试输出流");
System.out.println("========================");
outPutTest.bytes();
outPutTest.chars();
outPutTest.bytesBuffer();
outPutTest.charsBuffer();
}
}
测试结果
========================
测试输入流（文件大小：2.58MB）
========================
1.字节流输入
输入文件耗时：6723ms
2.字符流输入
输入文件耗时：522ms
3.字节缓冲流输入
输入文件耗时：14ms
4.字符缓冲流输入
输入文件耗时：98ms
========================
测试输出流
========================
1.字节流输出
输出文件耗时：19272ms
文件大小：7031KB
2.字符流输出
输出文件耗时：405ms
文件大小：7031KB
3.字节缓冲流输出
输出文件耗时：38ms
文件大小：7031KB
4.字符缓冲流输出
输出文件耗时：45ms
文件大小：7031KB
Process finished with exit code 0
结果分析
-
有缓冲区的操作都比没有缓冲区的效率高
-
输入流中，由于输入流的文件对象是.pdf对象，不是文本文件，从而带缓冲区的字节流比带缓冲区的字符流效率更高
-
查看了StreamDecoder的源码，从而知道FileReader类（字符输入流）默认会有一个DEFAULT_BYTE_BUFFER_SIZE 默认缓冲区大小8192，所以会比字节输入流快。
-
BufferReader中是将数据放到缓冲区。
FileReader是用来读文件的类，而BufferReader是将IO流转换为Buffer以提高程序的处理速度
-
BufferedInputStream（带缓冲区的字节输入流）在实现的时候是在自身read方法中提供缓存，是一次取1024或更多字节然后再慢慢读，一个个的返回，它并没有实现读一行的方法
BufferedReader（字符缓冲流输入）在实现时通过提供一个readLine方法，使用数组或者stringBuilder存储一行数据，并一次性返回
五、字节序
字节序，顾名思义字节的顺序，再多说两句就是大于一个字节类型的数据在内存中的存放顺序(一个字节的数据当然就无需谈顺序的问题了)。其实大部分人在实际的开 发中都很少会直接和字节序打交道。唯有在跨平台以及网络程序中字节序才是一个应该被考虑的问题。
类型
小端格式和大端格式(Little-Endian&Big-Endian)
不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序。
最常见的有两种：
1． Little-endian：将低序字节存储在起始地址（低位编址）
2． Big-endian：将高序字节存储在起始地址（高位编址）
C语言中的二进制和文本文件的读取效率比较
测试代码
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
double txtRead(char* filePath){
FILE* fpRead = fopen(filePath, "r");
clock_t start, finish;
int a=0;
if (fpRead == NULL)
{
printf("文件打开失败");
return 0;
}
start = clock();
while (!feof(fpRead))
{
a = fgetc(fpRead);
}
finish = clock();
double text_duration = (double)(finish - start) / CLOCKS_PER_SEC;
fclose(fpRead);
return text_duration;
}
double binaryRead(char* filePath){
FILE* fbRead = fopen(filePath,"rb");
clock_t start, finish;
int a=0;
if (fbRead == NULL)
{
printf("文件打开失败");
return 0;
}
start = clock();
while (!feof(fbRead))
{
a = fgetc(fbRead);
}
finish = clock();
fclose(fbRead);
double binary_duration = (double)(finish - start) / CLOCKS_PER_SEC;
return binary_duration;
}
int main()
{
char filePath[10] = "D:\\1.txt";
printf("文本格式总耗时：%f 秒\n", txtRead(filePath));
printf("二进制格式总耗时：%f 秒\n", binaryRead(filePath));
return 1;
}
测试结果
[Running] cd "e:\VSCodeConfiguration\Java\" && gcc clock_test.c -o clock_test && "e:\VSCodeConfiguration\Java\"clock_test
文本格式总耗时：3.678000 秒
二进制格式总耗时：3.048000 秒
[Done] exited with code=1 in 7.1 seconds
结果分析
二进制格式的读取要比文本格式的读取快一点
六、思考总结
- 源码中很多都有写明作用，直接看源码效率更高
- 字符流默认有一个缓冲区
- 学会看官方文档，Java的官方文档对IO类都有说明
参考链接
Java 流(Stream)、文件(File)和IO | 菜鸟教程
输入和输出(IO)概述_java_dreamzuora的博客-CSDN博客
(2条消息)java字节流与字符流的区别_java_呼卓宇的博客-CSDN博客
(2条消息)JAVA基础知识之StreamDecoder流_java_咕噜是个胖子-CSDN博客
(2条消息)FileReader和BufferedReader的区别_java_meihuai7538的博客-CSDN博客
C 字符串 | 菜鸟教程
------------恢复内容结束------------