Java核心教程：深入解析文件输入输出流（IO流）

时间：11-12 民间故事提交错误

按流量方向分：输入流量和输出流量。例如：InputStream和OutputStream

IO流常用的基类：

* InputStream、OutputStream

字符流的抽象基类：

* Reader、Writer

字符流和字节流的区别：

1、读取字节流时，读取一个字节就返回一个字节；字符流使用字节流时读取一个或多个字节（中文对应的字节数为2，在UTF-8码表中为3个字节）。首先检查指定的编码表并返回找到的字符。 2.字节流可以处理所有类型的数据，如图片、MP3、AVI视频文件，而字符流只能处理字符数据。只要处理纯文本数据，就必须优先使用字符流。否则，使用字节流。

二、字符流

Paste_Image.png

1. 字符流简介：

字符流中的对象与编码表集成，这是系统默认的编码表。我们的系统一般都是GBK编码的。字符流只用来处理文本数据，字节流用来处理媒体数据。数据最常见的表达方式是文件，使用字符流操作文件的子类一般是FileReader和FileWriter。

2.字符流读写：

注：

写入文件后，必须使用flush()刷新它。

使用后记得关闭流

使用流对象会抛出IO 异常

定义文件路径时，可以使用“/”或“”。

创建文件时，如果目录中存在同名文件，则会覆盖该文件。

读取文件时，必须保证该文件已经存在，否则会出现异常。

示例1：在硬盘上创建一个文件并写入一些文本数据

类FireWriterDemo {

public static void main(String[] args) throws IOException { //需要处理IO异常

//创建一个FileWriter对象。一旦对象初始化完毕，要操作的文件就必须清楚。

//并且该文件将在指定目录中创建。如果目录中存在同名文件，则该文件将被覆盖。

FileWriter fw=new FileWriter("F:\1.txt");//目的是明确数据要存储的目的地。

//调用write方法将字符串写入流中

fw.write("你好世界！");

//刷新流对象缓冲区中的数据并将数据flush到目的地

fw.flush();

//关闭流资源，但关闭前会刷新内部缓冲区的数据。当我们完成输入后，我们必须close();

fw.write("first_test");

fw.close();

//flush和close的区别：flush后可以继续输入，但close后不能继续输入。

}

}代码示例：将当前项目目录下的a.txt内容复制到当前项目目录下的b.txt

公共类CopyFileDemo2 {

公共静态无效主（字符串[] args）抛出IOException {

//封装数据源

FileReader fr=new FileReader("a.txt");

//封装目的地

FileWriter fw=new FileWriter("b.txt");

//一次一个字符

//int ch=0;

//while ((ch=fr.read()) !=-1) {

//fw.write(ch);

//}

//一次一个字符数组

char[] chs=新的char[1024];

int len=0;

while ((len=fr.read(chs)) !=-1) {

fw.write(chs, 0, len);

fw.flush();

}

//释放资源

fw.close();

fr.close();

}

3.字符缓冲流

字符流还提供了相应的字符缓冲流，用于高效的读写。 BufferedWriter：字符缓冲输出流，BufferedReader：字符缓冲输入流。

BufferedWriter基本用法

将文本写入字符输出流，缓冲单个字符，提供单个字符、数组和字符串的高效写入。您可以指定缓冲区的大小，或接受默认大小。在大多数情况下，默认值足够大。

代码示例：BufferedWriter基本用法

/**

* 为了高效读写，字符流还提供了相应的字符缓冲流。

* BufferedWriter:字符缓冲输出流

* BufferedReader:字符缓冲输入流

* BufferedWriter:字符缓冲输出流

* 将文本写入字符输出流，缓冲单个字符，提供单个字符、数组和字符串的高效写入。

* 您可以指定缓冲区大小，或接受默认大小。在大多数情况下，默认值足够大。

公共类BufferedWriterDemo {

公共静态无效主（字符串[] args）抛出IOException {

//BufferedWriter(写入器输出)

//BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(

//new FileOutputStream("bw.txt")));

BufferedWriter bw=new BufferedWriter(new FileWriter("bw.txt"));

bw.write("你好");

bw.write("世界");

bw.write("java");

bw.flush();

bw.close();

}

BufferedReader基本用法

从字符输入流读取文本，缓冲单个字符以实现字符、数组和行的高效读取。可以指定缓冲区大小，也可以使用默认大小。在大多数情况下，默认值足够大。

代码示例： BufferedReader基本用法

公共类BufferedReaderDemo {

公共静态无效主（字符串[] args）抛出IOException {

//创建字符缓冲区输入流对象

BufferedReader br=new BufferedReader(new FileReader("bw.txt"));

//方法一

//int ch=0;

//while ((ch=br.read()) !=-1) {

//System.out.print((char) ch);

//}

//方法2

char[] chs=新的char[1024];

int len=0;

while ((len=br.read(chs)) !=-1) {

System.out.print(new String(chs, 0, len));

}

//释放资源

br.close();

}

特殊功能

BufferedWriter, newLine(): 根据系统判断换行符BufferedReader, String readLine(): 一次读取一行数据

代码示例：字符缓冲流的特殊方法

public class BufferedDemo {

公共静态无效主（字符串[] args）抛出IOException {

//写（）;

读（）;

}

private static void read() 抛出IOException {

//创建字符缓冲区输入流对象

BufferedReader br=new BufferedReader(new FileReader("bw2.txt"));

//public String readLine(): 一次读取一行数据

//字符串行=br.readLine();

//System.out.println(line);

//行=br.readLine();

//System.out.println(line);

//最终代码

字符串行=空；

while ((line=br.readLine()) !=null) {

System.out.println(行);

}

//释放资源

br.close();

}

private static void write() 抛出IOException {

//创建字符缓冲区输出流对象

BufferedWriter bw=new BufferedWriter(new FileWriter("bw2.txt"));

for (int x=0; x 10; x++) {

bw.write("你好" + x);

//bw.write("rn");

bw.newLine();

bw.flush();

}

bw.close();

}

代码示例：字符缓冲流复制文本文件

* 需求：将当前项目目录下的a.txt内容复制到当前项目目录下的b.txt

*数据来源：

* a.txt -- 读取数据-- 字符转换流-- InputStreamReader -- FileReader -- BufferedReader

* 目的地：

* b.txt -- 写出数据-- 字符转换流-- OutputStreamWriter -- FileWriter -- BufferedWriter

公共类CopyFileDemo2 {

公共静态无效主（字符串[] args）抛出IOException {

//封装数据源

BufferedReader br=new BufferedReader(new FileReader("a.txt"));

//封装目的地

BufferedWriter bw=new BufferedWriter(new FileWriter("b.txt"));

//读取和写入数据

字符串行=空；

while ((line=br.readLine()) !=null) {

bw.write(行);

bw.newLine();

bw.flush();

}

//释放资源

bw.close();

br.close();

}

三、字节流

1.概述：

1、字节流和字符流的基本操作是一样的，但是如果要操作媒体流，就需要使用字节流。

2、因为字节流是对字节进行操作的，所以可以用它来操作媒体文件。（媒体文件也是以字节为单位存储的）

3、读写字节流：InputStream输入流（读）和OutputStream输出流（写）

4、字节流操作不需要刷新流操作。

5.InputStream独有的方法：

int available();//返回文件的字节数注意：可以使用该方法指定读取模式下传递的数组长度，从而省去循环判断。但如果文件较大，虚拟机启动默认分配的内存一般为64M。当文件太大时，这个数组长度占用的内存空间就会溢出。因此，该方法要谨慎使用，当文件不大时可以使用。

1.字节流写数据的方式

* 字节输出流操作步骤：

* A: 创建字节输出流对象

* B:调用write()方法

* C: 释放资源

* public void write(int b): 写入一个字节

* public void write(byte[] b): 写入字节数组

* public void write(byte[] b,int off,int len): 写入字节数组的一部分

公共类FileOutputStreamDemo2 {

公共静态无效主（字符串[] args）抛出IOException {

//创建字节输出流对象

//OutputStream os=new FileOutputStream("fos2.txt"); //多态

FileOutputStream fos=new FileOutputStream("fos2.txt");

//调用write()方法

//fos.write(97); //97 --底层二进制数据--通过记事本打开--找到97对应的字符值--a

//fos.write(57);

//fos.write(55);

//public void write(byte[] b):写入字节数组

字节[] bys={97,98,99,100,101};

fos.write(bys);

//public void write(byte[] b,int off,int len): 写入字节数组的一部分

fos.write(bys,1,3);

//释放资源

fos.close();

}

字节流写数据加入异常处理

公共类FileOutputStreamDemo4 {

公共静态无效主（字符串[] args）{

//单独做异常处理

//文件输出流fos=null;

//尝试{

//fos=new FileOutputStream("fos4.txt");

//} catch (FileNotFoundException e) {

//e.printStackTrace();

//}

//尝试{

//fos.write("java".getBytes());

//} catch (IOException e) {

//e.printStackTrace();

//}

//尝试{

//fos.close();

//} catch (IOException e) {

//e.printStackTrace();

//}

//一起做异常处理

//尝试{

//FileOutputStream fos=new FileOutputStream("fos4.txt");

//fos.write("java".getBytes());

//fos.close();

//} catch (FileNotFoundException e) {

//e.printStackTrace();

//} catch (IOException e) {

//e.printStackTrace();

//}

//改进版本

//为了在finally中看到该对象，它必须在外部定义。为了避免访问时出现问题，必须给出一个初始化值。

文件输出流fos=null;

尝试{

//fos=new FileOutputStream("z:\fos4.txt");

fos=new FileOutputStream("fos4.txt");

fos.write("java".getBytes());

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} 最后{

//仅当fos 不为null 时才需要Close()

如果（fos！=null）{

//为了保证close()会被执行，我们把它放在这里。

尝试{

fos.close();

} catch (IOException e) {

e.printStackTrace();

}

2.字节流读取数据

* 字节输入流操作步骤：

* A: 创建字节输入流对象

* B:调用read()方法读取数据并将数据显示在控制台上

* C: 释放资源

* 读取数据的方法：

* A:int read(): 一次读取一个字节

* B:int read(byte[] b): 一次读取一个字节数组

* C:int read(byte[] b): 一次读取一个字节数组

* 返回值实际上是实际读取的字节数。

公共类FileInputStreamDemo {

公共静态无效主（字符串[] args）抛出IOException {

//文件输入流（字符串名称）

//FileInputStream fis=new FileInputStream("fis.txt");

FileInputStream fis=new FileInputStream("FileOutputStreamDemo.java");

////调用read()方法读取数据并将数据显示在控制台上

////第一次读取

//int by=fis.read();

//System.out.println(by);

//System.out.println((char) by);

////第二次读取

//by=fis.read();

//System.out.println(by);

//System.out.println((char) by);

////第三次读取

//by=fis.read();

//System.out.println(by);

//System.out.println((char) by);

////我们发现代码非常重复，所以我们需要使用循环来改进它

////使用循环时，最麻烦的就是如何控制循环判断条件？

////第四次读取

//by=fis.read();

//System.out.println(by);

////第五次读取

//by=fis.read();

//System.out.println(by);

////通过测试，我们知道如果读取到的数据为-1，则表示已经读取到文件末尾。

//用循环改进

//int by=fis.read();

//while (by !=-1) {

//System.out.print((char) by);

//by=fis.read();

//}

//最终代码

整数=0；

//读取、赋值、判断

while ((by=fis.read()) !=-1) {

System.out.print((char) by);

}

//数组长度一般为1024或者1024的整数倍

字节[] bys=新字节[1024];

我

nt len = 0; while ((len = fis.read(bys)) != -1) { System.out.print(new String(bys, 0, len)); } // 释放资源 fis.close(); } }

字节流复制数据练习

/* * 需求：把c盘下的a.txt的内容复制到d盘下的b.txt中 * * 数据源： * c:\a.txt -- 读取数据-- FileInputStream * 目的地： * d:\b.txt -- 写出数据 -- FileOutputStream */ public class CopyFileDemo2 { public static void main(String[] args) throws IOException { // 封装数据源 FileInputStream fis = new FileInputStream("c:\a.txt"); // 封装目的地 FileOutputStream fos = new FileOutputStream("d:\b.txt"); // 复制数据 int by = 0; while ((by = fis.read()) != -1) { fos.write(by); } // 释放资源 fos.close(); fis.close(); } }

3.字节缓冲流

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流。字节缓冲输出流：BufferedOutputStream，字节缓冲输入流：BufferedInputStream。 /* * 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。 * 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。 * 这种类被称为：缓冲区类(高效类) * 写数据：BufferedOutputStream * 读数据：BufferedInputStream * * 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。 * * 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢? * 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。 */ public class BufferedOutputStreamDemo { public static void main(String[] args) throws IOException { // BufferedOutputStream(OutputStream out) // FileOutputStream fos = new FileOutputStream("bos.txt"); // BufferedOutputStream bos = new BufferedOutputStream(fos); // 简单写法 BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("bos.txt")); // 写数据 bos.write("hello".getBytes()); // 释放资源 bos.close(); } }

字节缓冲流复制数据练习

/* * 需求：把e:\a.mp4复制到当前项目目录下的b.mp4中 * * 字节流四种方式复制文件： * 基本字节流一次读写一个字节：共耗时：117235毫秒 * 基本字节流一次读写一个字节数组：共耗时：156毫秒 * 高效字节流一次读写一个字节：共耗时：1141毫秒 * 高效字节流一次读写一个字节数组：共耗时：47毫秒 */ public class CopyMp4Demo { public static void main(String[] args) throws IOException { long start = System.currentTimeMillis(); // method1("e:\a.mp4", "copy1.mp4"); // method2("e:\a.mp4", "copy2.mp4"); // method3("e:\a.mp4", "copy3.mp4"); method4("e:\a.mp4", "copy4.mp4"); long end = System.currentTimeMillis(); System.out.println("共耗时：" + (end - start) + "毫秒"); } // 高效字节流一次读写一个字节数组： public static void method4(String srcString, String destString) throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream( srcString)); BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(destString)); byte[] bys = new byte[1024]; int len = 0; while ((len = bis.read(bys)) != -1) { bos.write(bys, 0, len); } bos.close(); bis.close(); } // 高效字节流一次读写一个字节： public static void method3(String srcString, String destString) throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream( srcString)); BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(destString)); int by = 0; while ((by = bis.read()) != -1) { bos.write(by); } bos.close(); bis.close(); } // 基本字节流一次读写一个字节数组 public static void method2(String srcString, String destString) throws IOException { FileInputStream fis = new FileInputStream(srcString); FileOutputStream fos = new FileOutputStream(destString); byte[] bys = new byte[1024]; int len = 0; while ((len = fis.read(bys)) != -1) { fos.write(bys, 0, len); } fos.close(); fis.close(); } // 基本字节流一次读写一个字节 public static void method1(String srcString, String destString) throws IOException { FileInputStream fis = new FileInputStream(srcString); FileOutputStream fos = new FileOutputStream(destString); int by = 0; while ((by = fis.read()) != -1) { fos.write(by); } fos.close(); fis.close(); }