InputStream类、OutputStream类、BufferedInputStream类与BufferedOutputStream类--Java基础084

最新推荐文章于 2024-04-13 22:28:55 发布

醉小义

最新推荐文章于 2024-04-13 22:28:55 发布

阅读量601

点赞数

CC 4.0 BY-SA版权

分类专栏： java基础文章标签： io流

本文链接：https://blog.youkuaiyun.com/qq_30638831/article/details/72812103

java基础专栏收录该内容

96 篇文章

订阅专栏

本文深入讲解Java中的IO流技术，包括文件操作、字节流与字符流的区别、缓冲流的应用等核心概念，并提供了详细的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.sqf.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

/*
 File类: 用于描述一个文件或者文件夹的。
 
 通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。
 
IO流（Input Output）

IO流解决问题： 解决设备与设备之间的数据传输问题。  内存--->硬盘   硬盘--->内存


IO流技术：


IO流分类：
	如果是按照数据的流向划分：
		
		输入流
		
		
		输出流
		
	如果按照处理的单位划分：
	
		字节流: 字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。
		
		
		字符流： 字符流读取的数据是以字符为单位的 。 字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能 识别的字符。  
				字符流 = 字节流 + 解码
				
输入字节流：
--------| InputStream 所有输入字节流的基类  抽象类
------------| FileInputStream  读取文件数据的输入字节流 
			
使用FileInputStream读取文件数据的步骤：
	1. 找到目标文件
	2. 建立数据的输入通道。
	3. 读取文件中的数据。
	4. 关闭 资源.

问题1： 读取完一个文件的数据的时候，我不关闭资源有什么影响?
 答案： 资源文件一旦 使用完毕应该马上释放，否则其他的程序无法对该资源文件进行其他 的操作。
				 
 */
public class Demo {
	
	
	public static void main(String[] args) throws IOException {
		readTest4();
		
	}
	//方式4：使用缓冲数组配合循环一起读取。28
	public static void readTest4() throws IOException {
		File file = new File("g:\\a.txt");
		FileInputStream in = new FileInputStream(file);
		int length = 0;
		byte[] buf = new byte[1024];
		
		while((length=in.read(buf))!=-1){
			System.out.println(new String(buf,0,length));
		}
	}

	//读取的方式一缺陷： 无法读取完整一个文件 的数据.
	public static void readTest1() throws FileNotFoundException, IOException {
		//1. 找到目标文件
		File file = new File("g:\\a.txt");
		//建立数据的输入通道。
		FileInputStream in = new FileInputStream(file);
		//读取文件中的数据
		int content = in.read();
		
		System.out.println((char)content);
		//关闭资源    实际上就是释放资源。 
		in.close();
	}
	
	//方式2 ： 使用循环读取文件的数据
	public static void readTest2() throws IOException {
		
		long startTime = System.currentTimeMillis();
		//找到目标文件
		File file = new File("g:\\a.jpg");
		//建立数据的输入通道
		FileInputStream in = new FileInputStream(file);
		//读取文件的数据
		int content = 0;//声明该变量用于存储读取到的数据
		while((content=in.read())!=-1){
			System.out.println((char)content);
		}
		in.close(); //关闭资源
		
		long endTime = System.currentTimeMillis();
		System.out.println("读取的时间:" + (endTime-startTime));
	}
	
	//方式3：使用缓冲 数组 读取。    缺点： 无法读取完整一个文件的数据。     12G
	public static void readTest3() throws IOException {
		File file = new File("g:\\a.txt");
		
		FileInputStream in = new FileInputStream(file);
		//建立缓冲字节数组，读取文件的数据。
		byte[] buf = new byte[1024];//建立缓冲字节数组，读取文件的数据。
		int length = in.read(buf);
		// 如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
		System.out.println("length:" + length);
		
		String content = new String(buf,0,length);
		System.out.println("内容:" + content);
		
		in.close();
	}
	
}

package com.sqf.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 输出字节流：
 
 --------| OutputStream 是所有输出字节流 的父类。  抽象类
 -----------| FileOutStream 向文件输出数据的输出字节流。
 
FileOutputStream如何使用呢？
	1. 找到目标文件
	2. 建立数据的输出通道。
	3. 把数据转换成字节数组写出。
	4. 关闭资源

FileOutputStream要注意的细节：
	1. 使用FileOutputStream 的时候，如果目标文件不存在，那么会自动创建目标文件对象。 
	2. 使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
	3.使用FileOutputStream写数据的时候, 如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。
	4.使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据，只是
	把低八位的二进制数据写出，其他二十四位数据全部丢弃。
	 
	 00000000-000000000-00000001-11111111   511
	 
	 
	 11111111---> -1 
 */
public class Demo2 {
	
	public static void main(String[] args) throws IOException {
		writeTest4();
	}
	
	 
	//需求： 拷贝一张图片。
	private static void writeTest4() throws IOException {
		//找到目标文件
		File file = new File("g:\\a.jpg");
		File aimFile = new File("g:\\r.jpg");
		//建立数据的输入输出通道
		FileInputStream in = new FileInputStream(file);
		FileOutputStream out = new FileOutputStream(aimFile);
		//每新创建一个FileOutputStream的时候，默认情况下FileOutputStream 的指针是指向了文件的开始的位置。 每写出一次，指向都会出现相应移动。
		//建立缓冲数据，边读边写
		byte[] buf = new byte[1024];
		int length = 0;
		while((length=in.read(buf))!=-1){
			out.write(buf, 0, length);
		}
		//关闭资源 原则： 先开后关，后开先关。
		out.close();
		in.close();
		
	}

	public static void writeTest3() throws IOException {
		
		File file = new File("g:\\b.txt");
		FileOutputStream out = new FileOutputStream(file);
		String data = "abcasd";
		byte[] buf = data.getBytes();
		out.write(buf, 0, 2);//  将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。
	}

	//使用字节数组把数据写出。
	public static void writeTest2() throws IOException {
		
		File file = new File("g:\\b.txt");
		FileOutputStream out = new FileOutputStream(file);
		String data = "\r\nhello world!";
		out.write(data.getBytes());
		out.close();
	}

	//每次只能写一个字节的数据出去。
	public static void writeTest1() throws IOException {
		
		File file = new File("g:\\b.txt");
		FileOutputStream out = new FileOutputStream(file);
		out.write('h');
		out.write('e');
		out.write('l');
		out.write('l');
		out.write('o');
		
		out.close();
	}
	
}

package com.sqf.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
IO异常 的处理
*/
public class Demo3 {
	
	public static void main(String[] args) throws IOException {
		//readTest();
		copyImage();
	}

	
	public static void copyImage() {
		
		FileInputStream in = null;
		FileOutputStream out = null;
		
		try {
			File inFile = new File("g:\\a.jpg");
			File outFile = new File("g:\\r.jpg");
			
			in = new FileInputStream(inFile);
			out = new FileOutputStream(outFile);
			
			int length = 0;
			byte[] buf = new byte[1024];
			while((length=in.read(buf))!=-1){
				out.write(buf, 0, length);
			}
		} catch (IOException e) {
			System.out.println("拷贝图片出错...");
			throw new RuntimeException(e);
		}finally{
			// 关闭资源
			try {
				if (out != null) {
					out.close();
					System.out.println("关闭输出流对象成功...");
				}
			} catch (IOException e) {
				System.out.println("关闭输出流资源失败...");
				throw new RuntimeException(e);
			} finally {
				if (in != null) {
					try {
						in.close();
						System.out.println("关闭输入流对象成功...");
					} catch (IOException e) {
						System.out.println("关闭输入流对象失败...");
						throw new RuntimeException(e);
					}
				}

			}
		}
		
	}


	public static void readTest()  {
		FileInputStream in = null;
		
		try {
			
			File file = new File("g:\\a.txt");
			 in = new FileInputStream(file);
			
			int length = 0;
			byte[] buf = new byte[1024];
			while((length=in.read())!=-1){
				System.out.println(new String(buf,0,length));
			}
		}catch (IOException e) {
			/*
			 * //处理的代码... 首先你要阻止后面的代码执行,而且要需要通知调用者这里出错了... throw new
			 * RuntimeException(e);
			 * //把IOException传递给RuntimeException包装一层，然后再抛出，这样子做的目的是
			 * 为了让调用者使用变得更加灵活。
			 */
			System.out.println("读取文件资源错误。。。。。");
			throw new RuntimeException(e);
		}finally{
			try {
				if (in != null) {
					in.close();
				}
			} catch (Exception e) {
				System.out.println("关闭资源失败...");
				throw new RuntimeException(e);
			}
		}
		
	}
	
}

package com.sqf.io;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import javax.imageio.stream.FileImageInputStream;

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

输入字节流体系： 
----| InputStream  输入字节流的基类。 抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流    缓冲输入字节流的出现主要是为了提高读取文件数据的效率。    
其实该类内部只不过是维护了一个8kb的字节数组而已。 

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

使用BufferedInputStream的步骤	:
	1. 找到目标文件。
	2. 建立数据 的输入通道
	3. 建立缓冲 输入字节流流
	4. 关闭资源
*/
public class Demo4 {
	
	public static void main(String[] args) throws IOException {
		//readTest();
		teadTest2();
	}
	
	private static void teadTest2() throws IOException {
		
		File file = new File("g:\\a.txt");
		
		FileInputStream in = new FileInputStream(file);
		//疑问一 为什么创建BufferInputStream的时候需要传递FileInputStream？
		//BufferInputStream本身是不具读备文件的能力，所以需要借助FileInputStream来读文件的数据。
		BufferedInputStream bis = new BufferedInputStream(in);
		
		int content = 0;
		while((bis.read())!=-1){
			System.out.println((char)content);
		}
		//关闭资源
		bis.close();////调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
	}

	//读取文件的时候我们都是使用缓冲数组读取。效率会更加高
	@SuppressWarnings("resource")
	public static void readTest() throws IOException{
		File file = new File("g:\\a.txt");
		
		FileImageInputStream in = new FileImageInputStream(file);
		byte[] buf = new byte[1024*8];
		int length = 0;
		while((length=in.read(buf))!=-1){
			System.out.println(new String(buf,0,length));
		}
		in.close();
	}
	
}

package com.sqf.io;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
输出字节流
--------| OutputStream  所有输出字节流的基类  抽象类
------------| FileOutputStream 向文件 输出数据 的输出字节流
------------| Bufferedoutputstream  缓冲输出字节流    BufferedOutputStream出现的目的是为了提高写数据的效率。 
        						内部也是维护了一个8kb的字节数组而已。
 
 使用BufferedOutputStream的步骤：
 	1. 找到目标文件
 	2. 建立数据的输出通道

 
BufferedOutputStream 要注意的细节
	1. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
 	2. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
 	调用flush方法或者是close方法、 或者是内部维护的字节数组已经填满数据的时候。
 */
public class Demo5 {
	
	@SuppressWarnings("resource")
	public static void main(String[] args) throws IOException {
		//找到目标文件
		File file = new File("g:\\a.txt");
		//建立数据的输出通道
		FileOutputStream out = new FileOutputStream(file);
		//建立缓冲输出字节流对象
		BufferedOutputStream bot = new BufferedOutputStream(out);
		//把数据写出
		bot.write("hello world".getBytes());
		//bot.flush();  //把缓冲数组中内部的数据写到硬盘上面。
		bot.close();//这个方法的底层调用了flush()方法
	}
	
}

package com.sqf.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 练习： 使用缓冲输入输出字节流拷贝一个图片。
 * */

public class CopyImage {
	
	@SuppressWarnings("resource")
	public static void main(String[] args) throws IOException {
		File inFile = new File("g:\\a.jpg");
		File outFile = new File("g:\\aa.jpg");
		
		FileInputStream in = new FileInputStream(inFile);
		FileOutputStream out = new FileOutputStream(outFile);
		
		BufferedInputStream bis = new BufferedInputStream(in);
		BufferedOutputStream bos = new BufferedOutputStream(out);
		
		/*
			int length = 0;
		          方法一:  如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
			byte[] buf = new byte[1024];
			while((length = bis.read(buf))!=-1){
				bos.write(buf, 0, length);
			}
		*/
		int content = 0;
		while((content=bis.read())!=-1){
			bos.write(content);//如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
			//bos.flush(); //刷新缓冲区数据     
		}

		bos.close();
		bis.close();
		
	}
}