Java基础之——IO流（字节流）

字节流

字节输出流OutputStream

OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能法方法。

FileOutputStream类

OutputStream有很多子类，其中FileOutputStream可用来写入数据到文件中。
FileOutputStream类是文件输出流，是用于将数据写入File的输出流。

使用FileOutputStream写数据到文件中

代码演示

public class FileOutputStreamDemo {
		public static void main(String[] args) throws IOException {
			//需求：将数据写入到文件中。
			//创建存储数据的文件。
			File file = new File("d:\\file.txt");
			//创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
			//输出流目的是文件，会自动创建。如果文件存在，则覆盖。
			FileOutputStream fos = new FileOutputStream(file);
			//调用父类中的write方法。
			byte[] data = "abcde".getBytes();
			fos.write(data);
            //关闭流资源。
			fos.close();
		}
}

运行结果

会发现我们的D盘内多了“file.txt”文件，且文件内有我们写入的内容“abcde”.

给文件续写和换行

如果我们直接 new FileOutputStream(file) 这样创建对象写入数据的话，会覆盖掉原有的文件，那我们想要在原有的文件中续写内容该怎么办呢？
查阅API我们会发现

当第二个参数为true时，使用该流写出的数据会追加到文件末尾

如果想给文件中续写数据和换行，我们可以这样写

public class FileOutputStreamDemo_2 {
		public static void main(String[] args) throws IOException {
			File file = new File("d:\\file.txt");
			FileOutputStream fos = new FileOutputStream(file, true);
			String str = "\r\n"+"Java";
			fos.write(str.getBytes());
			fos.close();
		}
	
}

打开我们刚才的文件，我们会发现文件中的内容变成如下图所示：

说完输出流，我们来看输入流

字节输入流InputStream

前面我们了解到了如何将内存中的数据写到文件中，那么如何将文件中的数据读到内存中呢，我们可以通过InputStream来实现，此类是表示字节输入流的所有类的超类，定义了字节输入流的基本共性能方法。

FileInputStream类

InputStream有很多子类，其中FileInputStream可用来读取文件中的内容。

FileInputStream类读取数据read方法

从文件中读取数据代码如下所示：

public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
		FileInputStream fis = new FileInputStream("d:\\file.txt");
		//读取数据。使用 read();一次读一个字节。
		int d = -1;
		while((d=fis.read())!=-1){
			System.out.print((char)d+" ");
		}
		fis.close();
}
}

这是我们刚才写入文件的内容

读取数据read(byte[])方法

在读取文件中的内容时调用read() 方法，每次只能读取一个，太麻烦了，也是我们可以定义一个数组作为临时的存储容器，一次可以读取多个字符。
代码如下：

public class FileOutputStream_2 {
	public static void main(String[] args) throws IOException {
		/*
		 * 演示第二个读取方法， read(byte[]);
		 */
		// 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
		FileInputStream fis = new FileInputStream("d:\\file.txt");		
		//创建一个字节数组。
		byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。		
		int len = -1;
		while((len=fis.read(buf))!=-1){
			System.out.println(new String(buf,0,len));
		}
		fis.close();
	}
}

文件复制

读取一个已有的数据，并且将这些数据写入到另外一个文件中。

public class CopyFileTest {
	public static void main(String[] args) throws IOException {
		//1,明确源和目的。
		File srcFile = new File("d:\\file.txt");
		File destFile = new File("d:\\copyfile.txt");
		
		//2,明确字节流 输入流和源相关联，输出流和目的关联。
		FileInputStream fis = new FileInputStream(srcFile);
		FileOutputStream fos = new FileOutputStream(destFile);
		
		//3, 使用输入流的读取方法读取字节，并将字节写入到目的中。
		int ch = -1;
		while((ch=fis.read())!=-1){
			fos.write(ch);
		}
		//4,关闭资源。
		fos.close();
		fis.close();
	}

检查文件发现file.txt 的内容被copyfile.txt辅助


上述复制文件有个问题，每次都从源文件读取一个，然后在写到指定文件，接着再读取一个字符，然后再写一个，一直这样下去。效率极低。

缓冲数组方式复制文件

示范代码如下：

public class CopyFileByBufferTest {
	public static void main(String[] args) throws IOException {
		File srcFile = new File("d:\\file.txt");
		File destFile = new File("d:\\copyfile2.txt");
		// 明确字节流 输入流和源相关联，输出流和目的关联。
		FileInputStream fis = new FileInputStream(srcFile);
		FileOutputStream fos = new FileOutputStream(destFile);
		//定义一个数组缓冲区。
		byte[] buf = new byte[1024];
		int len = -1;
		while ((len = fis.read(buf)) != -1) {
			fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
		}
		// 关闭资源。
		fos.close();
		fis.close();
	}
}

IO异常的处理

在刚才的程序运行过程中，我们会发现出现了异常，那么我们在实际开发中是怎么处理异常呢，请看我们下面的代码演示：

public class FileOutputStreamDemo3 {
	public static void main(String[] args) {
		//定义FileOutputStream的引用
		FileOutputStream fos = null;
		try {
			//创建FileOutputStream对象
			fos = new FileOutputStream("d:\\file.txt");
			//写出数据
			fos.write("abcde".getBytes());
		} catch (IOException e) {
			System.out.println(e.toString() + "----");
		} finally {
			//一定要判断fos是否为null，只有不为null时，才可以关闭资源
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					throw new RuntimeException("");
				}
			}
		}
	}
}