Java之IO（一） FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream

最新推荐文章于 2022-11-30 21:16:56 发布

麦客子

最新推荐文章于 2022-11-30 21:16:56 发布

阅读量325

点赞数

分类专栏： Java 文章标签： IO java

本文链接：https://blog.csdn.net/a911711054/article/details/77400257

版权

Java 专栏收录该内容

96 篇文章 0 订阅

订阅专栏

package com.shuhuadream.file;

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

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

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

IO流（Input Output）

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


IO流技术：


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


				 
*/
public class Demo01 {
	public static void main(String[] args) {
		readTest04();
	}
	
	//方式四  使用缓冲数组配合循环一起使用
	/*************推荐使用******************/
	public static void readTest04(){
		//找到目标文件
		File file = new File("d:\\demo\\a.txt");
		FileInputStream fis = null;
		//建立缓冲数组配合循环读取文件的数据
		byte[] buf = new byte[1024];
		try {
			//建立数据的输入通道
			fis = new FileInputStream(file);
			int length = 0;//定义变量，保存实际读取到的字节数
			while((length=fis.read(buf))!=-1){//read方法返回的是下一个字节，如果读到了文件的末尾，那么会返回-1表示
				System.out.println(new String(buf,0,length));
				//String(byte[] byte,int offset,int length)   offset:要解码的第一个byte的索引 length:需要解码的byte数
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	//方式三  无法完整读取一个文件的数据
	public static void readTest03(){
		//找到目标文件
		File file = new File("d:\\demo\\a.txt");
		FileInputStream fis = null;
		byte[] buf = new byte[1024];
		try {
			fis = new FileInputStream(file);
			int length = fis.read(buf);
			String content = new String(buf,0,length);// 如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
			System.out.println(content);
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		
	}
	
	//读取方式二：使用循环读取文件的数据
	public static void readTest02(){
		//找到目标文件啊
		File file = new File("d:\\demo\\a.txt");
		FileInputStream fis = null;
		try {
			//建立数据的输入通道
			fis = new FileInputStream(file);
			//读取文件中的数据
			int content = 0;//声明变量用于存储读取到的数据
			while((content = fis.read())!=-1){
				System.out.println((char)content);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				//关闭资源
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}		
	
	//读取方式一：无法读取完整的一个文件数据
	public static void readTest01(){
		//找到目标文件啊
		File file = new File("d:\\demo\\a.txt");
		FileInputStream fis = null;
		try {
			//建立数据的输入通道
			fis = new FileInputStream(file);
			//读取文件中的数据
			int read = fis.read();//read() 读取一个字节的数据
			System.out.println(read);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				//关闭资源
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}		
	}
}

package com.shuhuadream.file;

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

/**
 * ------------|OutputStream	是所有输出字节流的父类。 抽象类
 * --------------|FileOutputStream   向文件输出数据的输出字节流
 * 
 * FileOutputStream 如何使用？
 * */
public class Demo02 {
	public static void main(String[] args) {
		writeTest01();
	}
	
	public static void writeTest01(){
		//找到目标文件
		File file = new File("d:\\demo\\a.txt");
		FileOutputStream fos = null;
		String str = "\r\n大河向东流";
		
		byte[] data = str.getBytes();
		try {
			fos = new FileOutputStream(file,true);
			fos.write(data,0,data.length);
			fos.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

package com.shuhuadream.file;

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

public class Test01 {
	public static void main(String[] args) {
		//找到目标文件
		File file1 = new File("d:\\demo\\1.jpg");
		File file2 = new File("d:\\demo\\2.jpg");
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		int length = 0;
		byte[] buf = new byte[1024];//缓冲数组
		try {
			//建立数据的输入输出通道
			fis = new FileInputStream(file1);
			fos = new FileOutputStream(file2);
			//边读边写
			while((length=fis.read(buf))!=-1){
				fos.write(buf,0,length);
			}
		} catch (FileNotFoundException e) {
			//e.printStackTrace();
			throw new RuntimeException(e);
		} catch (IOException e) {
			//e.printStackTrace();
			throw new RuntimeException(e);
		}finally{
			try {
				if(fos!=null){
					fos.close();
				}		
			} catch (IOException e) {
				e.printStackTrace();
			}finally{
				if(fis!=null){
					try {
						fis.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
			
		}
		
	}
	
}

package com.shuhuadream.buffer;

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

/*
 * 文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
 * 这时候sun给我们提供了一个---------缓冲输入字节流对象，让我们可以更高效率读取文件
 * 
 * 输入字节流体系：
--------| InputStream 所有输入字节流的基类  抽象类
------------| FileInputStream  读取文件数据的输入字节流 
------------| BufferedInputStream  缓冲输入字节流 缓冲输入字节流的出现主要是为了提高读取文件数据的效率

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

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

使用BufferedInputStream的步骤：
	1.找到目标文件

 */
public class Demo01 {
	public static void main(String[] args) {
		bis();
	}
	
	public static void bis(){
		//找到目标文件
		File file = new File("d:\\demo\\a.txt");
		FileInputStream fis = null;
		BufferedInputStream bis = null;
		try {
			//建立数据的输入通道
			fis = new FileInputStream(file);
			//建立缓冲输入字节流
			bis = new BufferedInputStream(fis);
			int content = 0;
			//读入文件数据
			while((content=bis.read())!=-1){
				System.out.print((char)content);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bis!=null){
				try {
					//关闭资源
					bis.close();//调用bis的close方法实际上关闭的是fis
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

package com.shuhuadream.buffer;

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.使用BufferedOutputStream写数据的时候，它的write方法是先把数据写到它的内部维护的数组中
 * 		2.如果需要把数据真正写到硬盘上面，需要调用flush方法或者close方法，或者是内部维护的字节数组已经填满的时候
 * */
public class Demo02 {
	public static void main(String[] args) {
		//找到目标文件
		File file = new File("d:\\demo\\a.txt");
		FileOutputStream fos1 = null;
		BufferedOutputStream bos = null;
		
			try {
				//建立数据的输出通道
				fos1 = new FileOutputStream(file);
				//建立缓冲输出字节流对象
				bos = new BufferedOutputStream(fos1);
				//准备数据源
				String str = "hello world";
				byte[] data = str.getBytes();
				//写数据
				bos.write(data);
				//刷新流
				bos.flush();
			} catch (FileNotFoundException e1) {
				e1.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}finally{
				try {
					//关闭流
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
		}
	}
}

package com.shuhuadream.buffer;

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 Test01 {
	public static void main(String[] args) {
		//找到目标文件
		File file1 = new File("d:\\demo\\1.jpg");
		File file2 = new File("d:\\demo\\3.jpg");
	
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			//建立输入输出通道
			bis = new BufferedInputStream(new FileInputStream(file1));
			bos = new BufferedOutputStream(new FileOutputStream(file2));
			int content = 0;
			//int length = bufferedInputStream.read(buf);如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组的字节个数
			//边读边写
			while((content = bis.read())!=-1){//如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容
				bos.write(content);
				//bos.flush(); //不用写这句，数组满了8kb自动会刷新流，就算是最后没满8kb，close也会自动刷出去
				}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				//关闭流
				bos.close();
				bis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		}
	}
}

麦客子

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java之IO（一） FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream

package com.shuhuadream.file;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;/*File类: 用于描述一个文件或者文件夹的。通过File对象我们可以读取文件或者文件夹的
复制链接

扫一扫