黑马程序员-IO_字节流应用

最新推荐文章于 2025-09-05 13:33:51 发布

原创最新推荐文章于 2025-09-05 13:33:51 发布 · 133 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

java 专栏收录该内容

48 篇文章

订阅专栏

本文详细介绍了如何利用字节流与字符流技术进行图片与音视频数据的复制操作，包括读取、写入流程及优化策略。通过实例演示，展示了使用字节流实现图片复制的完整过程，以及如何通过缓冲区提高复制效率。此外，还探讨了如何使用缓冲流实现MP3文件的高效复制。最后，深入解析了字节流read方法返回int类型的原因，解释了其背后的原理。

---------------------- android培训、java培训、期待与您交流！ ----------------------

字节流

字符流：

FileReader

FileWriter。

字符流缓冲区：

BufferedReader

BufferedWriter

字节流：

InputStream

OutputStream

字节流缓冲区：

BufferedInputStream

BufferedOutputStream

需求，想要操作图片数据。这时就要用到字节流。

复制一个图片.

import java.io.*;
class  FileStream
{
	public static void main(String[] args) throws IOException
	{
		readFile_3();
	}
	//使用字符流读取文件方式3
	public static void readFile_3()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");
		
//		int num = fis.available();//该方法获取到将要进行读取的流中的数据长度。
		byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用在循环了。

		fis.read(buf);

		System.out.println(new String(buf));

		fis.close();
	}

	//使用字节流读取数据方法2，一次读取多个数据存入到缓冲区，一次进行打印。
	public static void readFile_2()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");
		//建立byte数组，用于存放临时数据。
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=fis.read(buf))!=-1)//将数据读取到byte数组中去，返回读取字节个数。
		{
			System.out.println(new String(buf,0,len));//将读取到数组中的数据进行打印，从0到有效个数。
		}

		fis.close();
		
	}

	//使用字节流读取文件中的数据打印到控制台上，一次读取一个字节
	public static void readFile_1()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");

		int ch = 0;
		//使用read方法，一次读取一个字节的数据。
		while((ch=fis.read())!=-1)
		{
			System.out.println((char)ch);//强转为字符类型进行打印
		}

		fis.close();
	}
	//使用字节流向文件中写入一段数据
	public static void writeFile()throws IOException
	{
		//创建文件字节流对象
		FileOutputStream fos = new FileOutputStream("fos.txt");
		//通过gatBytes方法将字符串转换为字节数组，然后写入到流中去。
		fos.write("abcde".getBytes());
		//注意：使用字节流不需要刷新，数据就能存入到文件中。
		fos.close();

		
	}
}

复制一个图片

思路：

1，用字节读取流对象和图片关联。

2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。

3，通过循环读写，完成数据的存储。

4，关闭资源。

import java.io.*;
class  CopyPic
{
	public static void main(String[] args) 
	{
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try
		{
			fos = new FileOutputStream("c:\\2.bmp");//创建字节输入流和输出流对象
			fis = new FileInputStream("c:\\1.bmp");

			byte[] buf = new byte[1024];//建立缓冲的数组

			int len = 0;
			//使用read方法将数据读取到数组中
			while((len=fis.read(buf))!=-1)
			{
				fos.write(buf,0,len);//将数组中的数据写入到输出流中去。
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("复制文件失败");
		}
		finally
		{
			try
			{
				if(fis!=null)
					fis.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
			try
			{
				if(fos!=null)
					fos.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}

演示mp3的复制。通过缓冲区。

BufferedOutputStream

BufferedInputStream

import java.io.*;
class  CopyMp3
{
	public static void main(String[] args) throws IOException
	{
		long start = System.currentTimeMillis();//获取时间，用于计算复制过程中消耗的时间
		copy_1();
		long end = System.currentTimeMillis();

		System.out.println((end-start)+"毫秒");
	}
	//使用自己写的字节流缓冲区地方法进行读取
	public static void copy_2()throws IOException
	{
		MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\\9.mp3"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\3.mp3"));
		
		int by = 0;

		//System.out.println("第一个字节:"+bufis.myRead());

		while((by=bufis.myRead())!=-1)
		{
			bufos.write(by);
		}

		bufos.close();
		bufis.myClose();
	}

	//通过字节流的缓冲区完成复制。
	public static void copy_1()throws IOException
	{
		//创建两个流对象，并使用缓冲流进行装饰。
		BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));
		
		int by = 0;
		//使用一次读取一个字节的方式，耗时稍多。
		while((by=bufis.read())!=-1)
		{
			bufos.write(by);
		}

		bufos.close();
		bufis.close();

		
	}
}

根据BufferedInputStream中的原理，自定义一个字节缓冲流。定义一个读取方法。

import java.io.*;

class MyBufferedInputStream
{
	private InputStream in;

	private byte[] buf = new byte[1024*4];//建立缓冲区
		
	private int pos = 0,count = 0;//定义计数器和指针
	
	MyBufferedInputStream(InputStream in)//构造方法接收一个流对象
	{
		this.in = in;
	}

	//一次读一个字节，从缓冲区(字节数组)获取。
	public int myRead()throws IOException
	{
		//通过in对象读取硬盘上数据，并存储buf中。
		if(count==0)
		{
			count = in.read(buf);//count是读取到的字节的个数
			if(count<0)
				return -1;//读取到文件结束返回-1
			pos = 0;//对指针进行初始化

			byte b = buf[pos];//得到一个字节

			count--;//计数器自减
			pos++;//指针自增一次
			return b&255;//将得到的一个字节返回，为避免连续8个一出现-1，所以&255.
		}
		else if(count>0)
		{
			byte b = buf[pos];//如果缓冲区中还有数据就继续返回。知道没有为止。

			count--;
			pos++;
			return b&0xff;
		}
		return -1;

	}
	public void myClose()throws IOException
	{
		in.close();
	}
}

read方法读取到的是一个byte类型的数据，返回的为什么是int类型呢？

是因为字节数据在内存中是以二进制数据的形式存在的，并且不规则排列，会出现连续多个1的情况，转换为10进制以后就是-1.所以要对二进制数据进行处理。

byte: -1 ---> int : -1;

00000000 00000000 00000000 11111111 ：8个1是 255

类型提升以后，在前面补全1，，其值同样是-1，也不是我们想要的结果。

11111111 11111111 11111111 11111111

11111111 -->提升了一个int类型那不还是-1吗？是-1的原因是因为在8个1前面补的是1导致的。

那么我只要在前面补0，即可以保留原字节数据不变，又可以避免-1的出现。

怎么补0呢？

11111111 11111111 11111111 11111111

&00000000 00000000 00000000 11111111

------------------------------------