10、I/O 输入输出流_下列reader类的常用方法中,将数据直接读入字符输出流的是( ) aint read() blon-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_42263859/article/details/125618918

			Java高级特性-【第4章】Java I/O和反射机制
			
（1）File类：操作文件或者目录属性的类
		构造方法：
			File(String pathname): 用指定的文件路径构造文件,例如：File file = new File("F:/domo.txt");
			File(String dir,String subpath):在指定的目录下创建指定的文件名的文件，dir参数指定目录文件，subpath参数指定文件名
			File(File parent,String subpath)：根据一个文件对象和字文件构造文件对象，parent参数指定目录文件，subpath参数指定文件名
		掌握该类中常用的方法
			1) boolean exists():判断文件或目录是否存在
			2) boolean isFile():判断是否是文件
			3) isDirectory():判断是否是目录
			4) String getPath():返回此对象表示的文件的相对路径名
			5) String getAbsolutePath():返回此对象表示的文件的绝对路径名
			6) boolean createNewFile():创建名称的空文件，不创建文件夹
			7) 相对路径getPath()和绝对路径getAbsolutePath()的不同
				相对路径：相较于某个路径下，指明的路径
				绝对路径：包含盘符在内的文件或文件目录的路径
			8) String getName():返回由此抽象路径名表示的文件或目录的名称。
			9) boolean delete():删除此抽象路径名表示的文件或目录。
			10) long length():获取文件内容的长度
			11) boolean mkdir():创建此抽象路径名指定的目录。

(2)流：传输数据的通道
		按照传输方向分类：
			输入流：InputStream、Stream
			输出流：OutputStream、Writer
		按照数据处理单元分类：
			字节流：InputStream、OutputStream
			字符流：Reader、Writer
			
(3)InputStream类(抽象类)：字节输入流，是一个抽象类，不能实例化
(4)FileInputStream类（是InputStream的子类，可以实例化）
		构造方法：
			FileInputStream(File file)
			FileInputStream(String path)
		掌握该类中常用的方法
			read():从此输入流中读取一个数据字节
			read(byte[] b):从指定文件中读取数据，将读取的数据存储在一个byte类型的数组中，返回值表示从文件中读取的内容长度
			close():关闭此文件输入流并释放与此流有关的所有系统资源。
	
	
(5)OutputStream(抽象类):字节输出流，是一个抽象类，不能实例化
(6)FileOutputStream类（是OutputStream的子类，可以实例化）	
		构造方法：
			FileOutputStream(File file)：
			FileOutputStream(File file,boolean bool)：
			FileOutputStream(String path)：通过此构造方法创建的对象，使用write()方法写入数据的时候，会将文件中原来的数据进行覆盖
			FileOutputStream((String path,boolean bool)：通过此构造方法创建的对象，并将构造方法第二个参数设置为true，使用write()方法写入数据的时候，数据写入在文件的末尾位置；第二个参数为false，写入内容会覆盖文件中原来的内容
		掌握该类中常用的方法			
			write(int b): 将指定字节写入此文件输出流。
			write(byte[] b):将 b.length 个字节从指定 byte 数组写入此文件输出流中。
			close():关闭此文件输出流并释放与此流有关的所有系统资源	


(7)Reader类(抽象类)：字符输入流，是一个抽象类，不能实例化			
(8)InputStreamReader类（Reader类的子类）：该类可以按照指定编码格式读取数据
 		构造方法：
 			InputStreamReader(InputStream is)：创建一个使用默认字符集的 InputStreamReader，注意：InputStream是一个抽象类，不能直接创建对象，可以创建它的子类FileInputStream类对象，例如：InputStream is = new FileInputStream(file);
 			InputStreamReader(InputStream is,String charset name):创建使用给定字符集的 InputStreamReader,例如：
 		掌握该类中常用的方法
 			int read():从输入流中读取下一个字节数据
 			int read(char[] ch):从流中读取数据，并将数据存储在ch这个数组中，返回值表示从流中读取的数据个数
 			close():关闭此文件输出流并释放与此流有关的所有系统资源。
			
(9)FileReader类（InputStreamReader类子类）：该类只能按照平台默认编码读取数据
 		构造方法：
			FileReader(File file):例如，FileReader fr = new FileReader(file);
			FIleReader(String pathName):例如，FileReader fr = new FileReader("F:/Myeclipse/demo.txt");
		掌握该类中常用的方法
 			int read():从输入流中读取下一个字节数据
 			int read(char[] ch):从流中读取数据，并将数据存储在ch这个数组中，返回值表示从流中读取的数据个数
 			close():关闭此文件输出流并释放与此流有关的所有系统资源。			
			
(10)BufferedReader类(Reade类的子类)：缓冲输入流，这个类可以高效率的一行一行的读取数据			
		构造方法：
			BufferedReader(Reader in): 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
		掌握该类中常用的方法：
			readLine():一行一行的读取数据
			read():读取单个字符
			close():关闭此文件输出流并释放与此流有关的所有系统资源。


(11)Writer类(抽象类)：字符输出流，是一个抽象类，不能实例化
(12)OutputStreamWriter类（Writer的子类）
		构造方法：
			OutputStreamWriter(OutputStream os)
			OutputStreamWriter(OutputStream os,String charset)
(13))FileWriter类（OutputStreamWriter类的子类）
		构造方法：
			FileWriter(File file)
			FileWriter(String path)
			FileWriter(File file,boolean bool)
			FileWriter(String path,boolean bool)
(14)BufferedWriter类(Writer类的子类):缓冲输出流，这个类可以高效率的一行一行的写入数据
		构造方法：
			BufferedWriter(Writer wr)
(15)DataInputStream类（InputStream类的孙子类，注：是FilterInputStream的子类）
		构造方法：
			DataInputStream(InputStream in)
(16)DataOutputStream类（OutputStream类的孙子类，注：是FilterInputStream的子类）
		构造方法：
			DataOutputStream(OutputStream os)
(17)序列化：将对象写入到特定的流中，将对象存储到文件中
	反序列化：从特定的流中构造对象的过程，从文件中读取对象信息
(18)ObjectInputStream类（InputStream类的子类）
		构造方法：
			ObjectInputStream()
			ObjectInputStream(InputStream is)
(19)ObjectOutputStream类（OutputStream类的子类）	
		构造方法：
			ObjectOutputStream()
			ObjectOutputStream(OutputStream os)

01、File类（操作文件或目录属性）

1、File类的概述

（1）java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关

（2）File 能新建、删除、重命名文件和目录，但File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

（3）想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

（4）File对象可以作为参数传递给流的构造器

2、File类的常用方法

表 File类的构造方法
方法	说明
File(String pathname)	用指定的文件路径构造文件
File(String dir,String subpath)	在指定的目录下创建指定的文件名的文件，dir参数指定目录文件，subpath参数指定文件名
File(File parent,String subpath)	根据一个文件对象和字文件构造文件对象，parent参数指定目录文件，subpath参数指定文件名

表 File类的常用方法
方法名称	说明
boolean exists()	判断文件或目录是否存在
boolean isFile()	判断是否是文件
boolean isDirectory()	判断是否是目录
String getPath()	返回此对象表示的文件的相对路径名
String getAbsolutePath()	返回此对象表示的文件的绝对路径名
boolean createNewFile()	创建名称的空文件，不创建文件夹
String getName()	返回由此抽象路径名表示的文件或目录的名称
boolean delete()	删除此抽象路径名表示的文件或目录
long length()	获取文件内容的长度

示例1：File类的常用方法


package cn.bdqn.demo01;

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

public class FileDemo01 {

	public static void main(String[] args) {
		/*
		 * (1)boolean exists():判断文件或目录是否存在
		 * (2)boolean isFile():判断是否是文件
		 * (3)isDirectory():判断是否是目录
		 * (4)String getPath():返回此对象表示的文件的相对路径名
		 * (5)String getAbsolutePath():返回此对象表示的文件的绝对路径名
		 * (6)boolean createNewFile():创建名称的空文件，不创建文件夹
		 * (7)相对路径getPath()和绝对路径getAbsolutePath()的不同
		 * 		相对路径：相较于某个路径下，指明的路径
		 * 		绝对路径：包含盘符在内的文件或文件目录的路径
		 * (8)String getName():返回由此抽象路径名表示的文件或目录的名称。
		 * (9)boolean delete():删除此抽象路径名表示的文件或目录。
		 * (10)long length():获取文件内容的长度
		 * 
		 * */
		
		
		
		//创建File类对象
		File file1 = new File("F:\\demo.txt");
		File file2 = new File("F:\\text");
		
		//通过file调用方法实现对文件属性的操作
		
		System.out.println("---------------------(1)boolean exists():----------------");
		//(1)boolean exists():判断文件或目录是否存在
		boolean result1 = file1.exists();
		System.out.println("file1对象指向的文件存在："+result1);
		boolean result2 = file2.exists();
		System.out.println("file2对象指向的目录存在："+result2);

		System.out.println("---------------------(2)boolean isFile():----------------");
		//(2)boolean isFile():判断是否是文件
		System.out.println("file1对象指向的是一个文件："+file1.isFile());
		System.out.println("file2对象指向的是一个文件："+file2.isFile());
			
		System.out.println("---------------------(3)boolean isDirectory():----------------");
		//(3)isDirectory():判断是否是目录
		System.out.println("file1对象指向的是一个目录："+file1.isDirectory());
		System.out.println("file2对象指向的是一个目录："+file2.isDirectory());
		
		System.out.println("---------------------(4)String getPath():----------------");
		//(4)String getPath():返回此对象表示的文件的相对路径名
		String path1 = file1.getPath();
		System.out.println("file1对象指向的文件相对路径："+path1);
		
		String path2 = file2.getPath();
		System.out.println("file2对象指向的文件相对路径："+path2);
		
		System.out.println("---------------------(5)String getAbsolutePath():----------------");
		//(5)String getAbsolutePath():返回此对象表示的文件的绝对路径名
		String absolutePath1 = file1.getAbsolutePath();
		System.out.println("file1对象指向的文件绝对路径名："+absolutePath1);
		String absolutePath2 = file2.getAbsolutePath();
		System.out.println("file1对象指向的文件绝对路径名："+absolutePath2);
		
		System.out.println("---------------------(6)boolean createNewFile():----------------");
		//(6)boolean createNewFile():创建名称的空文件，不创建文件夹
		File file3 = new File("text.txt");//当file3创建text.txt没有具体的地址时，文件创建在该程序工程存放的目录文件夹下
		File file4 = new File("F:\\a");
		File file5 = new File("F:\\b");
		File file6 = new File("F:\\mm\\aa\\bb");
		
		try {
			//若不进行异常处理，将会出现
			boolean result3 = file3.createNewFile();
			boolean result4 = file4.createNewFile();
			System.out.println("file3 对象指向的文件创建成功："+result3);	
			System.out.println("file4 对象指向的文件创建成功："+result4);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("---------------------(7)相对路径getPath()和绝对路径getAbsolutePath()的不同:----------------");
		/*
		 * 以上述(6)中所述创建的file3为例，分别通过相对路径getPath()和绝对路径getAbsolutePath()进行显示，
		 * 相对路径：就是相对于自己的目标文件的位置。
		 * 绝对路径：是指文件在硬盘上真正存在的路径。
		 * */
		System.out.println(file3.getPath());//text.txt
		System.out.println(file3.getAbsolutePath());//D:\1.MyEclipse\word\day22输入输出流\text.txt
		
		System.out.println("---------------------(8)String getName():----------------");
		//(8)String getName():返回由此抽象路径名表示的文件或目录的名称。
		System.out.println(file1.getName());
		System.out.println(file2.getName());
		
		System.out.println("---------------------(9)boolean delete():----------------");
		//(9)boolean delete():删除此抽象路径名表示的文件或目录。
		System.out.println("file1对象指向的文件删除成功："+file1.delete());
		System.out.println("file2对象指向的文件删除成功："+file2.delete());
		
		System.out.println("---------------------(10)long length():----------------");
		//(10)long length():获取文件内容的长度
		//注：但是显示中文时，只能显示一个大概的数据长度
		File file7 = new File("f:/aaaa.txt");
		System.out.println(file7.length());
		
		
	}

}

02、Java中的流

思考：读文件是指把文件中的数据读取到内存中；写文件是把内存中的数据写到文件中。那通过什么读写文件呢？答案是流

1、Java流的分类

2、4个抽象类

InputStream类的常用子类为FileInputStream类，用于从文件中读取数据
OutputStream类的常用子类为FileOutputStream类，用于向文件写数据
Reader类的常用子类为BufferedReader，接受Reader对象作为参数，并对其添加字符缓冲器。
Writer类的常用子类为BufferedWriter，用于将数据缓冲到字符输出流

注意：

①在操作上字节流和字符流有一个区别，字符流在操作时使用了缓冲区（内部存储器），二字节流在操作时直接操作文件，不会使用缓冲区。

②所有的这些方法在出现错误时都会抛出IOException

（1）InputStream抽象类的常用方法

表 InputStream类的常用方法
方法	说明
int read()	从输入流中读取下一个字节数据
int read(byte[] b)	从输入流中读取数据，并将数据存储在缓冲区数组b中，返回实际读取的自结束
int read(byte[] b,int off,int len)	从输入流中读取最多len长度的字节，保存到字节数组b中，保存的位置从off开始
void close()	关闭输入流

（2）OutputStream抽象类的常用方法

表 OutputStream类的常用方法
方法	说明
void write(int c)	将指定的字节数据写入此输出流中
void write(byte[] buf)	将数组buf中的所有字节写入此输出流中
void write(byte[] b,int off,int len)	将字节数组中从偏移量off开始的长度为len的字节数据输出到输出流中
void close()	关闭输出流

（3）Reader抽象类的常用方法

表 Reader类的常用方法
方法	说明
int read()	从输入流中读取单个字符，返回所读取的字符数据
int read(char[] c)	从输入流中最多读取c.length个字符，保存到字符数组c中，返回实际读取的字符数
int read(char[] c,int off,int len)	从输入流中读取最多len个字符，保存到字符数组c中，保存的位置从off位置开始，返回实际读取的字符数
void close()	关闭流

（4）Writer抽象类的常用方法

表 Writer类的常用方法
方法	说明
void write(String str)	将str字符串里包含的字符输出到指定的输出流中
void write(String str,int off,int len)	将str字符串里从off位置开始，长度为len的多个字符输出到输出流中
void close()	关闭输出流
void flush()	刷新输出流

（2）FileInputStream（字节流，读文本文件）

（1）FileInputStream称为文件输入流；

（2）FileInputStream类是InputStream抽象类的一个子类；

（3）作用：将文件中的数据输入到内部存储器（简称内存）中，可以利用它来读取文本文件中的数据。

示例2：使用FileInputStream类读取文本文件的数据（int read()）

实现步骤：

①在F:/Myeclipse路径文件夹中创建aaaa.txt文件，文件中保存的内容为“abcdefg”.

代码：

package cn.bdqn.demo02;

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

public class FileInputStreamDemo01 {

	public static void main(String[] args) {
		//前提准备：先在F盘中创建一个aaaa.txt文件，并在其中输入若干数据
		
		//创建File类
		File file = new File("F:/Myeclipse/aaaa.txt");
		FileInputStream fis = null;//设初值
		
		//创建FileInputStream对象
		try {
			fis = new FileInputStream(file);//方法在出现错误时抛出异常
			//通过fis对象调用方法将文件里的内容读取进来
			int num;
			//read():从此输入流中读取一个数据字节。
			while((num=fis.read())!=-1){  //将从aaaa.txt中读取的一个数据字节赋值给num，并进行判断该数据字节是否为最后一个，若是则等于-1，若不是则执行while循环里的内容
				char ch = (char)num;//强制类型转换
				System.out.print(ch);
			}
			System.out.println();
			System.out.println("程序读取完毕");
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch(IOException e){
			e.printStackTrace();
		} finally{
			try {
				//close():关闭此文件输入流并释放与此流有关的所有系统资源。
				fis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

}

输出结果：

示例3：使用FileInputStream类读取文本文件的数据（int read(byte[] b)）

实现步骤：

①在F:/Myeclipse路径文件夹中创建bbbb.txt文件，文件中保存的内容为“ABCDEFG”.

代码：

package cn.bdqn.demo02;

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

public class FileInputStreamDemo02 {

	public static void main(String[] args) {
		//创建File类对象
		File file = new File("F:\\Myeclipse\\bbbb.txt");
		
		FileInputStream fis = null;//设初值
		try {
			//通过fis对象调用方法将文件里的内容读取出来
			fis = new FileInputStream(file);
			
			//read(byte[] b)方法需要一个byte类型的参数，准备一个byte类型的参数
			byte[] bytes = new byte[1024];
			
			//int read(byte[] bytes):从指定文件中读取数据，将读取的数据存储在一个byte类型的数组中，返回值表示从文件中读取的内容长度
			int num = fis.read(bytes);
			System.out.println(num);  //bytes数组内容长度为7
			for (int i = 0; i < bytes.length; i++) {
				System.out.print((char)bytes[i]);  //ABCDEFG
			}	
			System.out.println("程序读取文件完毕");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch(IOException e){
			e.printStackTrace();
		} finally{
			try {
				fis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}	
	}
}

输出结果：

03、读文本文件

1、FileOutputStream类（字节流，写文本文件）

创建一个OutputStream类对象指向FileOutputStream类对象，如下：

OutputStream os = new FileOutputStream("F:/aaaa.txt");

（1）FileOutputStream(String path)：通过构造方法创建的对象，使用write()方法写入数据的时候，会将原来的数据进行覆盖

（2）FileOutputStream(String path,boolean bool)：通过此构造方法创建的对象，并将构造方法的第二个参数设置为true，使用write()方法写入数据的时候,数据写入在文件的末尾位置；当第二个参数设置为false时，写入内容会覆盖文件中原来的内容。

示例4：使用FileOutputStream(String path)类向文本文件中写入数据（write(int c)）

实现步骤：

①在F:/Myeclipse路径文件夹中创建cccc.txt文件，文件中保存的内容为“zxcvb”.

代码：

package cn.bdqn.demo03;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class FileOutputStreamDemo01 {

	public static void main(String[] args) {


		OutputStream os = null;//设初值
		/*
		 * 创建一个OutputStream类对象指向FileOutputStream类对象：
		 * 如下：OutputStream os = new FileOutputStream("F:/aaaa.txt");
		 * */
		
		/*
		 * (1)FileOutputStream(String path):通过构造方法创建的对象，
		 * 使用write()方法写入数据的时候，会将原来的数据进行覆盖
		 * 
		 * 
		 * (2)FileOutputStream(String path,boolean bool):通过此构造方法创建的对象，
		 * 并将构造方法的第二个参数设置为true，使用write()方法写入数据的时候,数据写入
		 * 在文件的末尾位置；当第二个参数设置为false时，写入内容会覆盖文件中原来的内容。
		 * */
		try {
			os = new FileOutputStream("F:\\Myeclipse\\cccc.txt");
			
			//write():将指定的字节数据写入此文件输出流中。
			os.write(65);
			System.out.println("数据写入完毕");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			try {
				os.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

}

输出结果

写入的文本文档数据变为：

示例5：使用FileOutputStream(String path,boolean bool)类向文本文件中写入数据（write(int c)）

实现步骤：

①在F:/Myeclipse路径文件夹中创建dddd.txt文件，文件中保存的内容为“zxcvb”.

代码：

package cn.bdqn.demo03;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class FileOutputStreamDemo0101 {

	public static void main(String[] args) {

		OutputStream os = null;// 设初值
		/*
		 * 创建一个OutputStream类对象指向FileOutputStream类对象： 如下：OutputStream os = new
		 * FileOutputStream("F:/aaaa.txt");
		 */

		/*
		 * (1)FileOutputStream(String path):通过构造方法创建的对象，
		 * 使用write()方法写入数据的时候，会将原来的数据进行覆盖
		 * 
		 * 
		 * (2)FileOutputStream(String path,boolean bool):通过此构造方法创建的对象，
		 * 并将构造方法的第二个参数设置为true，使用write()方法写入数据的时候,数据写入
		 * 在文件的末尾位置；当第二个参数设置为false时，写入内容会覆盖文件中原来的内容。
		 */
		try {
			// os = new FileOutputStream("F:\\Myeclipse\\cccc.txt");
			os = new FileOutputStream("F:\\Myeclipse\\dddd.txt", true);

			// write():将指定的字节数据写入此文件输出流中。
			os.write(65);
			System.out.println("数据写入完毕");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (os != null) { // 判断os不等于null的时候，执行下一步
				try {
					os.close(); //关闭此文件输出流并释放与此流有关的所有系统资源。
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}

	}

}

输出结果：

当程序执行1遍时，文本文档的数据为：zxcvbA

当程序执行2遍时，文本文档的数据为：zxcvbAA

示例6：使用FileOutputStream(String path,boolean bool)类向文本文件中写入数据(write(byte[ ] b))

注意点

（1）使用了String类中的getBytes()方法，将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

实现步骤：

①在F:/Myeclipse路径文件夹中创建eeee.txt文件，文件中保存的内容为“ABC”.

代码：

package cn.bdqn.demo03;

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

public class FileOutputStreamDemo02 {

	public static void main(String[] args) {
		//创建File类对象
		File file = new File("F:\\Myeclipse\\eeee.txt");
		
		//创建FileOutputStream类对象
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file, true);
			
			//将一串字符写入到文件中
			String str = "Hello World";
			//getBytes():将字符串变成byte类型的数组
			byte[] bytes = str.getBytes();//调用String类中的getBytes()方法
			//write(byte[] b):将数组b中的所有字节写入此输出流中
			fos.write(bytes);
			System.out.println("数据写入完毕");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			try {
				fos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

输出结果：

执行1编程程序后，文本文档内数据变为：

3、InputStreamReader类(Reader的子类)

常用方法：

（1）

（2）

（3）

（4）

示例7：InputStreamReader类常用构造方法及常用方法（read()）

注意点：

当使用一步步的创建对象时，在关闭流时遵循一个原则：先开的后关，后开的先关

实现步骤：

①在F:/Myeclipse路径文件夹中创建demo.txt文件，文件中保存的内容为“sdfgh”.

package cn.bdqn.demo01;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo01 {

	public static void main(String[] args) throws IOException {
//		//创建File类对象
//		File file = new File("F:/Myeclipse/demo.txt");
//		
//		//创建InputStream类对象，但是InputStream类是一个抽象类，不能直接创建对象，可以创建它的子类FileInputStream类对象
//		InputStream is = new FileInputStream(file);
//		
//		//创建InputStreamReader类对象
//		InputStreamReader ir = new InputStreamReader(is);
		
		//将上述三者进行合并就成为了如下所示：
		InputStreamReader ir = new InputStreamReader(new FileInputStream("F:/Myeclipse/demo.txt"));
		//开始读取数据
		int num;
		while((num=ir.read())!=-1){ //判断当读取到最后时返回-1则表示遍历结束
			System.out.print((char)num);  
		}
		
		//注：关闭多个流的原则：先开的后关，后开的先关
		ir.close();//关闭流

	}

}

输出结果：

示例8：InputStreamReader类常用构造方法及常用方法(read(char[] ch))

实现步骤：

①在F:/Myeclipse路径文件夹中创建demo.txt文件，文件中保存的内容为“sdfgh”.

package cn.bdqn.demo01;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo02 {

	public static void main(String[] args) throws IOException {

		//创建InputStreamReader类对象
		InputStreamReader ir = new InputStreamReader(new FileInputStream("F:/Myeclipse/demo.txt"));
		
		char[] ch = new char[1024];
		int num = ir.read(ch);
		//System.out.println(num);//7：读取ch数组的长度，即domo.txt文件中的数据长度
		
		//遍历数组
		for (int i = 0; i < num; i++) {
			System.out.print(ch[i]);
		}
		
		ir.close();//关闭流
	}

}

输出结果：

4、FileReader类（字符流，InputStreamReader类子类）

示例9：FileReader类读取数据（read()）

实现步骤：

①在F:/Myeclipse路径文件夹中创建demo.txt文件，文件中保存的内容为“sdfgh”.

package cn.bdqn.demo01;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo01 {

	public static void main(String[] args) throws IOException{
		/*
		 * FileReader和BufferedReader两个类都是Reader抽象类的子类，
		 * 它们可以通过字符流的方式读取文件，并使用缓冲区，提高了文本文件的效率。
		 * 
		 * */
		
		//创建FileReader类对象
		FileReader fr = new FileReader("F:/Myeclipse/demo.txt");
		
		//int num = fr.read();
		//System.out.println((char)num);//s,只能读取一个字符
		
		//循环遍历
		int num;
		while((num=fr.read())!=-1){
			System.out.print((char)num);//sdfgh
		}
	}

}

输出结果：

5、BufferedReader类(字符流，Reader类的子类)

示例10：BufferReader类使用

package cn.bdqn.demo01;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class BufferedReaderDemo01 {

	public static void main(String[] args) throws IOException {
		//创建BufferedReade类对象
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("F:/Myeclipse/demo.txt"),"UTF-8"));

		String str;
		while((str=br.readLine())!=null){
			System.out.println(str);
		}
		br.close();
	}

}

输出结果：