Java中IO流的使用

最新推荐文章于 2023-05-17 17:28:35 发布

Snail_565

最新推荐文章于 2023-05-17 17:28:35 发布

阅读量603

点赞数 2

分类专栏： JavaSE 文章标签： IO流

本文链接：https://blog.csdn.net/Snail_565/article/details/100107918

版权

JavaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Java中IO流的使用

1 IO流的分类
- 1.2 什么是字节流
2 输入字节流
3 输出字节流
4 缓冲输入字节流
5 缓冲输出字节流
6 字符流
7 输出字符流
8 缓冲输入字符流
9 缓冲输出字符流

File类: 用于描述一个文件或者文件夹的。

通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。

1 IO流的分类

如果是按照数据的流向划分：输入流 和 输出流

输入流和输出流的定义方式：（以当前程序作为参照物，观察数据是流入还是流出，如果输出则使用输出流，如果数据是流入，则使用输入流。）

如果按照处理的单位划分：字节流 和 字符流

1.2 什么是字节流

字节流: 字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。

字符流：字符流读取的数据是以字符为单位的。字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能识别的字符。

2 输入字节流

--------| InputStream 所有输入字节流的基类抽象类
------------| FileInputStream 读取文件数据的输入字节流

使用FileInputStream读取文件数据的步骤：

找到目标文件
建立数据的输入通道。（FileInputStream就是这个“通道”）
读取文件中的数据。（read()方法一次只读取一个字节，read(字节数组)可以读多个字节，意思就是如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。）
关闭资源. （close）

具体实现如下：

//FileInputStream：输入字节流
	public static void fileInputStream() throws IOException{
		//找到目标文件
    	File file = new File("E:\\hello.txt");
    	//建立数据的输入通道
    	FileInputStream fileInputStream = new FileInputStream(file);
    	//建立缓冲数组配合循环读取文件的数据
    	int length = 0;  //保存每次读取到的字节个数。
    	byte[] buf = new byte[1024]; //存储读取到的数据   缓冲数组的长度一般是1024的倍数。因为与计算机的处理单位。理论上缓冲数组越大，效率越高
    	while((length = fileInputStream.read(buf)) != -1){  //read方法如果读取到了文件的末尾，那么会返回-1表示。
    		System.out.print(new String(buf,0,length));
    	}
    	fileInputStream.close();
    }

问题1：读取完一个文件的数据的时候，我不关闭资源有什么影响?
答案：资源文件一旦使用完毕应该马上释放，否则其他的程序无法对该资源文件进行其他的操作。

3 输出字节流

--------| OutputStream 是所有输出字节流的父类。抽象类
-----------| FileOutputStream 向文件输出数据的输出字节流。

FileOutputStream如何使用呢？

找到目标文件
建立数据的输出通道。
把数据转换成字节数组写出。
关闭资源

具体实现如下：

//输出字节流
    public static void fileOutputStream() throws IOException{
    	//找到目标文件
    	File file = new File("E:\\hello.txt");
    	//建立数据输出通道
    	FileOutputStream fileOutputStream = new FileOutputStream(file,true);
    	//把数据写出
    	String str = "对不起。";
    	byte[] buf = str.getBytes();
    	fileOutputStream.write(buf);
    	//关闭资源
    	fileOutputStream.close();
    }

FileOutputStream要注意的细节：

使用FileOutputStream 的时候，如果目标文件不存在，那么会自动创建目标文件对象。
使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
使用FileOutputStream写数据的时候, 如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。
使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据，只是把低八位的二进制数据写出，其他二十四位数据全部丢弃。

每新创建一个FileOutputStream的时候，默认情况下FileOutputStream的指针是指向了文件开始的位置。每写出一次，指向都会出现相应的移动。

用输入输出字节流做复制程序，程序如下：

//字节流复制文件程序
    public static void copy() throws IOException{
    	File inFile = new File("E:\\hello.txt");
    	File destFile = new File("E:\\hello2.txt");
    	FileInputStream fileInputStream = new FileInputStream(inFile);
    	FileOutputStream fileOutputStream = new FileOutputStream(destFile);
    	byte[] buf = new byte[1024];
    	int length = 0;
    	while((length = fileInputStream.read(buf)) != -1){
    		fileOutputStream.write(buf, 0, length);
    	}
    	fileOutputStream.close();
    	fileInputStream.close();
    }

在一个程序中分别使用到FileInputStream和FileOutputStream时的关闭资源原则：先开后关，后开先关

4 缓冲输入字节流

我们清楚读取文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
这时候sun给我们提供了一个------缓冲输入字节流对象,让我们可以更高效率读取文件。

输入字节流体系：
----| InputStream 输入字节流的基类。抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流缓冲输入字节流的出现主要是为了提高读取文件数据的效率。

其实该类内部只不过是维护了一个8kb的字节数组而已。

注意：凡是缓冲流都不具备读写文件的能力。

使用BufferedInputStream的步骤：

找到目标文件。
建立数据的输入通道
建立缓冲输入字节流
关闭资源

具体实现如下：

//缓冲输入字节流，不能读取汉字
    public static void bufferedInputStream() throws IOException{
    	//找到目标文件
    	File file = new File("E:\\hello.txt");
    	FileInputStream fileInputStream = new FileInputStream(file);
    	BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
    	
    	//读取文件数据
    	int content = 0;
    	while((content = bufferedInputStream.read()) != -1){
    		System.out.print((char)content);
    	}
    	//关闭资源
    	bufferedInputStream.close();//调用BufferedInputStream的close方法实际上关闭的是FileInputStream
    }

疑问一：为什么创建BufferedInputStream的时候需要传递FileInputStream?
答：BufferedInputStream本身是不具备读文件的能力，所以需要借助FileInputStream来读取文件的数据。

注意：调用BufferedInputStream的close方法实际上关闭的是FileInputStream。
疑问二：BufferedInputStream出现的目的是为了提高读取文件的效率，但是BufferedInputStream的read方法每次都只读取一个字节的数据，而FileInputStream每次也是读取一个字节的数据，那么BufferedInputStream效率高从何而来？
答：BufferedInputStream每次都是从内存中读数据，而FileInputStream是从硬盘中读数据

5 缓冲输出字节流

输出字节流
--------| OutputStream 所有输出字节流的基类抽象类
------------| FileOutputStream 向文件输出数据的输出字节流
------------| Bufferedoutputstream 缓冲输出字节流 BufferedOutputStream出现的目的是为了提高写数据的效率。
内部也是维护了一个8kb的字节数组而已。

使用BufferedOutputStream的步骤：

找到目标文件
建立数据的输出通道

具体实现内容如下：

//缓冲输出字节流
    public static void bufferedOutputStream() throws IOException{
    	//找到目标文件
    	File file = new File("E:\\hello.txt");
    	//建立数据的输出通道
    	FileOutputStream fileOutputStream = new FileOutputStream(file);
    	//建立缓冲输出字节流对象
    	BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
    	//把数据写出
    	bufferedOutputStream.write("大家好啊".getBytes());
    	//把缓冲数组中内部的数据写到硬盘上面。
    	bufferedOutputStream.close();
    }

BufferedOutputStream 要注意的细节

使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
调用flush方法或者是close方法、或者是内部维护的字节数组已经填满数据的时候。

6 字符流

字节流：字节流读取的是文件中的二进制数据，读到的数据并不会帮你转换成你看得懂的字符。

输入字符流：
----------| Reader 输入字符流的基类抽象类
-------------| FileReader 读取文件的输入字符流。

FileReader的用法：（FileReader默认使用的就是gbk编码表）

找到目标文件
建立数据的输入通道
读取数据
关闭资源

具体使用如下：

//输入字符流，但效率不如缓冲字符数组流
    public static void fileReader() throws IOException{
    	File file = new File("D:\\a.txt");
    	//建立数据的输入通道
    	FileReader fileReader = new FileReader(file);
    	int content = 0;
    	//fileReader中的read方法一次读一个字符，效率低
    	while((content = fileReader.read()) != -1){
    		System.out.print((char)content);
    	}
    	fileReader.close();
    }
    
    //使用缓冲字符数组流，输入
    public static void fileReader2() throws IOException{
    	File file = new File("D:\\a.txt");
    	FileReader fileReader = new FileReader(file);
    	char[] buf = new char[1024];
    	int length = 0;
    	while((length = fileReader.read(buf)) != -1){
    		System.out.print(new String(buf,0,length));
    	}
    	fileReader.close();
    }

7 输出字符流

------| Writer 输出字符流的基类。抽象类
-----------| FileWriter 向文件数据数据的输出字符流

FileWriter的使用步骤：

找到目标文件。
建立数据输出通道
写出数据。
关闭资源

FileWriter要注意的事项：
1, 使用FileWriter写数据的时候，FileWriter内部是维护了一个1024个字符数组的，写数据的时候会先写入到它内部维护的字符数组中，如果需要把数据真正写到硬盘上，需要调用flush或者是close方法或者是填满了内部的字符数组。
2, 使用FileWriter的时候，如果目标文件不存在，那么会自动创建目标文件。
3, 使用FileWriter的时候，如果目标文件已经存在了，那么默认情况会先情况文件中的数据，然后再写入数据，如果需要在原来的基础上追加数据，需要使用“new FileWriter(File , boolean)”的构造方法，第二参数为true。

何时使用字符流，何时使用字节流？依据是什么？

使用字符流的应用场景：如果是读写字符数据的时候则使用字符流（比较适合拷贝字符文件）。
使用字节流的应用场景：如果读写的数据都不需要转换成字符的时候，则使用字节流（比较适合拷贝图片,视频等数据）。

用输入输出字符流实现拷贝字符文件：具体实现如下

//用输入输出字符流实现拷贝字符文件：具体如下
    public static void copy2() throws IOException{
    	File inFile = new File("E:\\hello.txt");
    	File destFile = new File("E:\\hello2.txt");
    	FileReader fileReader = new FileReader(inFile);
    	FileWriter fileWriter = new FileWriter(destFile);
    	//建立缓冲字符数组进行边读边写
    	char[] buf = new char[1024];
    	int length = 0;
    	while((length = fileReader.read(buf)) != -1){
    		fileWriter.write(buf,0,length);
    	}
    	//关闭资源
    	fileWriter.close();
    	fileReader.close();
    }

8 缓冲输入字符流

输入字符流:
-------| Reader 所有输入字符流的基类。抽象类
----------| FileReader 读取文件字符串的输入字符流。
----------| BufferedReader 缓冲输入字符流。缓冲输入字符流出现的目的是为了提高读取文件的效率和拓展了FileReader的功能。其实该类内部也是维护了一个字符数组

记住：缓冲流都不具备读写文件的能力。

BufferedReader的使用步骤：
1.找到目标文件
2 .建立数据的输入通道。

使用方式如下：

//缓冲输入字符流，缓冲输入字符流出现的目的是为了提高读取文件的效率和扩展了FileReader的功能。其实该类内部也是维护了一个字节数组
    public static void bufferedReader() throws IOException{
    	//找到目标文件
    	File file = new File("F:\\a.txt");
    	//建立数据输入通道
    	FileReader fileReader = new FileReader(file);
    	//建立缓冲输入字符流
    	BufferedReader bufferedReader = new BufferedReader(fileReader);
    	//使用BufferedReader扩展功能，readLine()   一次读取一行文本，如果读到了文件的末尾返回null表示。
    	String line = null;
    	while((line = bufferedReader.readLine()) != null){ //虽然readLine每次读取一行数据，但是读取的line是不包含\r\n的
    		System.out.println(line);
    	}
    	//关闭资源
    	bufferedReader.close();
    }

使用BufferedReader拓展的功能，readLine() 一次读取一行文本，如果读到了文件的末尾返回null表示。
虽然readLine每次读取一行数据，但是返回的line是不包含\r\n的、

9 缓冲输出字符流

输出字符流
----------| Writer 所有输出字符流的基类，抽象类。
--------------- | FileWriter 向文件输出字符数据的输出字符流。
----------------| BufferedWriter 缓冲输出字符流缓冲输出字符流作用：提高FileWriter的写数据效率与拓展FileWriter的功能。

BufferedWriter内部只不过是提供了一个8192长度的字符数组作为缓冲区而已，拓展了FileWriter的功能。

BufferedWriter如何使用？
1. 找到目标文件
2. 建立数据的输出通道

使用方式如下：

//缓冲输出字符流，BuffereWriter里有一个newLine()方法：相当于"\r\n"换行
    public static void bufferedWriter() throws IOException{
    	File file = new File("D:\\a.txt");
    	FileWriter fileWriter = new FileWriter(file);
    	BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
    	bufferedWriter.write("大家好!!");
    	bufferedWriter.close();
    }

Snail_565

关注

2
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Java中IO流的使用

Java中IO流的使用1 IO流的分类1.2 什么是字节流2 输入字节流3 输出字节流4 缓冲输入字节流5 缓冲输出字节流6 字符流7 输出字符流8 缓冲输入字符流9 缓冲输出字符流File类: 用于描述一个文件或者文件夹的。通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。1 IO流的分类如果是按照数据的流向划分：输入流 ...
复制链接

扫一扫