IO流--字节流

最新推荐文章于 2023-07-22 13:17:56 发布

君丿莫悔

最新推荐文章于 2023-07-22 13:17:56 发布

阅读量115

点赞数

分类专栏：学习

本文链接：https://blog.csdn.net/qq_45212020/article/details/96703672

版权

学习专栏收录该内容

57 篇文章 4 订阅

订阅专栏

字节流

`
读取二进制数据并不转化为字符

输入字节流

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

使用FileInputStream读取文件数据的步骤：
1. 找到目标文件
2. 建立数据的输入通道。
3. 读取文件中的数据。
4. 关闭资源.
FileInputStream中read（）方法：从此输入流中读取一个数据字节并不加处理返回。如果没有输入可用，则此方法将阻塞。下一个数据字节如果已经到文件末尾则放回-1。read（）方法会抛出一个IOException。
读取方式一：（无法读取一个文件的完整数据）

	//读取的方式一缺陷： 无法读取完整一个文件 的数据.
	public static void readTest1() throws IOException{
		//1. 找到目标文件
		File file = new File("F:\\a.txt");
		//建立数据的输入通道。
		FileInputStream fileInputStream = new FileInputStream(file);
		//读取文件中的数据
		int content = fileInputStream.read(); // read() 读取一个字节的数据，把读取的数据不经处理返回。
		System.out.println("读到的内容是："+ (char)content);
		//关闭资源    实际上就是释放资源。 
		 fileInputStream.close();
	}
	
	
}

读取方式二：

//方式2 ： 使用循环读取文件的数据
	public static void readTest2() throws IOException{
		long startTime = System.currentTimeMillis();
		//找到目标文件
		File file = new File("F:\\美女\\1.jpg");
		//建立数据的输入通道
		FileInputStream fileInputStream = new FileInputStream(file);
		//读取文件的数据
		int content = 0; //声明该变量用于存储读取到的数据
		while((content = fileInputStream.read())!=-1){
			System.out.print((char)content);
		}
		//关闭资源
		fileInputStream.close();
		
		long endTime = System.currentTimeMillis();
		System.out.println("读取的时间是："+ (endTime-startTime)); //446
	}

读取方式三：（无法读取一个文件的完整数据）

	//方式3：使用缓冲 数组 读取。    缺点： 无法读取完整一个文件的数据。     12G
	public static void readTest3() throws IOException{
		//找到目标文件
		File file = new File("F:\\a.txt");
		//建立数据的输入通道
		FileInputStream fileInputStream = new FileInputStream(file);
		//建立缓冲字节数组，读取文件的数据。
		byte[] buf = new byte[1024];  //相当于超市里面的购物车。 缓冲数组 的长度一般是1024的倍数，因为与计算机的处理单位。  理论上缓冲数组越大，效率越高
		int length = fileInputStream.read(buf); // 如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
		System.out.println("length:"+ length);
		
		//使用字节数组构建字符串
		String content = new String(buf,0,length);//通过length限定字符串的长度以节省空间
		System.out.println("内容："+ content);
		//关闭资源
		fileInputStream.close();
	}

读取方式四（效率高推荐）：

	//方式4：使用缓冲数组配合循环一起读取。28
	public static void readTest4() throws IOException{
		long startTime = System.currentTimeMillis();
		//找到目标文件
		File file = new File("F:\\美女\\1.jpg");
		//建立数据的输入通道
		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();
		

		long endTime = System.currentTimeMillis();
		System.out.println("读取的时间是："+ (endTime-startTime)); //446
	}

FlieInputStream注意细节

1.资源文件一旦使用完毕应该马上释放，否则其他的程序无法对该资源文件进行其他的操作。
2.缓存数组的每次存储是覆盖操作如果覆盖单位不够则会保留一部分上次数组操作的数据所以输出时一定要对String类规范合适长度new String(buf,0,length)
缓冲数组存储覆盖问题
3.多数软件文档都是加密过的读取后会显示乱码

缓冲输入字节流BufferedInputStrean

缓冲输入字节流的出现主要时为了提高读取文件的效率其实该类的内部自不过是维护了一个8KB的字节数组
注意：凡是缓冲流都不具备读写文件的能力。

使用BufferedInputStream的步骤 :
1. 找到目标文件。
2. 建立数据的输入通道
3. 建立缓冲输入字节流流
4. 关闭资源

public class Demo1 {
	
	public static void main(String[] args) throws IOException {
		readTest2();
	}
	
	public static void readTest2() throws IOException{
		//找到目标文件
		File file = new File("F:\\a.txt");
		//读取文件数据
		int content = 0 ;
		while((content = fileInputStream.read())!=-1){
			System.out.print((char)content);
		}
		
		//关闭资源
		bufferedInputStream.close();//调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
	}

	
	
	//读取文件的时候我们都是使用缓冲数组读取。效率会更加高
	public static void readTest() throws IOException{
		File file = new File("F:\\a.txt");
		//建立数组通道
		FileInputStream fileInputStream = new FileInputStream(file);
		//建立缓冲数组读取数据
		byte[] buf = new byte[1024*8];
		int length = 0; 
		while((length = fileInputStream.read(buf))!=-1){
			System.out.print(new String(buf,0,length));
		}
		//关闭资源
		fileInputStream.close();
	}
	
	
}

输出字节流Outputstream

输出字节流：

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

FileOutputStream如何使用呢？
1. 找到目标文件
2. 建立数据的输出通道。
3. 把数据转换成字节数组写出。
4. 关闭资源

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

//每次只能写一个字节的数据出去。
	public static void writeTest1() throws IOException{
		//找到目标文件
		File file = new File("F:\\b.txt");
		//建立数据的输出通道
		FileOutputStream fileOutputStream = new FileOutputStream(file);
		//把数据写出
		fileOutputStream.write('h');
		fileOutputStream.write('e');
		fileOutputStream.write('l');
		fileOutputStream.write('l');
		fileOutputStream.write('o');
		//关闭资源
		fileOutputStream.close();

方式二
如果目标文件存在则会覆盖原内容
public static void main(String[] args) throws IOException {
writeTest3();
}

//使用字节数组把数据写出。
public static void writeTest3() throws IOException{
	//找到目标文件
	File file = new File("F:\\b.txt");
	//建立数据输出通道
	FileOutputStream fileOutputStream = new FileOutputStream(file);//覆盖原本内容
	//把数据写出。
	String data = "abc";
	byte[] buf = data.getBytes();
	fileOutputStream.write(buf, 0, 3); // 0 从字节数组的指定索引值开始写， 2：写出两个字节。

	//关闭资源
	fileOutputStream.close();
}

方式三
如果目标文件已经存在则在文件内容末尾追加数据


	//使用字节数组把数据写出。
	public static void writeTest2() throws IOException{
		//找到目标文件
		File file = new File("F:\\b.txt");
		//建立数据输出通道
		FileOutputStream fileOutputStream = new FileOutputStream(file,true);//加入true参数后如果目标文件已经存在则在文件末尾追加输出内容
		//把数据写出。
		String data = "\r\nhello world";
		fileOutputStream.write(data.getBytes());
		//关闭资源
		fileOutputStream.close();
	}

实战：

package FILE;//将图片拷贝

import java.io.*;


public class file01 {
	public static void main(String[] args){
		FileInputStream ip = null;
		FileOutputStream op =null;
		try{
			File file = new File("D:\\123.jpg");
			File file2 = new File("D:\\111.jpg");
			ip = new FileInputStream(file);
			op = new FileOutputStream(file2);
			int content = 0;
			while((content = ip.read())!= -1 ){
				op.write(content);
			}
		}catch(IOException e){
			System.out.println("拷贝失败");
			throw new RuntimeException(e);
		}finally{
			if(ip!=null&&op!=null){
				try{
					ip.close();
					op.close();
					System.out.println("关闭文件成功");
				}catch(IOException e){
					System.out.println("关闭文件失败");
				}
			}
		}

		
	}

}

缓冲输出字节流BufferedOutStream

内部也是维护了一个8kb的字节数组
使用BufferedOutputStream的步骤：
1. 找到目标文件
2. 建立数据的输出通道

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

public class Demo2 {

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

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

public class CopyImage {

	public static void main(String[] args) throws IOException {
		//找到目标文件
		File  inFile = new File("F:\\美女\\1.jpg");
		File outFile = new File("E:\\1.jpg");
		//建立数据输入输出通道
		FileInputStream fileInputStream = new FileInputStream(inFile);
		FileOutputStream fileOutputStream = new FileOutputStream(outFile);
		//建立缓冲输入输出流
		BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
		//边读边写
		int content = 0; 
		// int length = bufferedInputStream.read(buf);   如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
		while((content = bufferedInputStream.read())!=-1){ // 如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
			bufferedOutputStream.write(content);
		}
		//关闭资源
		bufferedInputStream.close();
		bufferedOutputStream.close();
	}
	
}

使用字节流写中文

字节流本身无法输入输出中文Byte类中会将中文编码成数字文件本身会将数字转换成中文

//使用字节流读取中文
	public static void readrTest() throws IOException{
		//找到目标文件
		File file = new File("F:\\a.txt");
		//建立数据的输入通道
		FileInputStream fileInputStream = new FileInputStream(file);
		//读取内容
		//int content = 0;
		
		/*while((content = fileInputStream.read())!=-1){ //出现乱码的原因： 一个中文在gbk码表中默认是占两个字节，
													   // 目前你只读取了一个字节而已，所以不是一个完整的中文。
			System.out.print((char)content);
		}*/
		
		byte[] buf = new byte[2];
		for(int i = 0 ; i < 3 ; i++){//一次读取两个字节组成一个汉字
			fileInputStream.read(buf);
			System.out.print(new String(buf));
		}
		//关闭资源
		fileInputStream.close();
		
	}

君丿莫悔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流--字节流

字节流`输入字节流--------| InputStream 所有输入字节流的基类抽象类------------| FileInputStream 读取文件数据的输入字节流使用FileInputStream读取文件数据的步骤：1. 找到目标文件2. 建立数据的输入通道。3. 读取文件中的数据。4. 关闭资源.FileInputStream中read（）方法：从此输入流中...
复制链接

扫一扫

专栏目录