Java OOP File IO章节

Java OOP File I/O章节

1.1操作文件或目录的属性

1.1.1使用File类操作文件或目录属性

​ （1）File对象既可以表示文件也可以表示目录，利用它可用来对文件或目录进行基本操作。语法：

	File file = new File(String pathName);
	//String pathName表示所指向的文件路径名

​ （2）File类的常用方法

方法名称	说明
boolean exists()	判断文件或目录是否存在
boolean isFile()	判断是否是文件
boolean isDirectory()	判断是否是目录
String getPath()	返回此对象表示的文件的相对路径名
String getAbsolutePath()	返回此对象表示的文件的绝对路径名
String getName()	返回此对象表示的文件或目录的名称
boolean delete()	删除此对象指定的文件或目录
boolean createNewFile()	创建名称的空文件，不创建文件夹
long length()	返回文件的长度，单位为字节，若文件不存在，则返回OL

​ （3）举例

public class FileMethods {
    public static void main(String[] args) {
        FileMethods fm = new FileMethods();
        java.io.File file = new java.io.File("E:\\save.txt");
        fm.showFileInfo(file);
    }
    /**
     * 显示文件信息
     */
    public void showFileInfo(java.io.File file) {
        if(file.exists()) {	//判断文件或目录是否存在
            if(file.isFile()) {	//如果是文件
                System.out.println("名称："+file.getName());
                System.out.println("相对路径："+file.getPath());
                System.out.println("绝对路径："+file.getAbsolutePath());
                System.out.println("文件大小："+file.length()+"字节");
            }
            if(file.isDirectory()) {
                System.out.println("此文件不存在！");
            }
        }else {
            System.out.println("文件不存在！");
        }
    }
}

public class FileMethods2 {
	public static void main(String[] args) {
		FileMethods2 fm = new FileMethods2();
		java.io.File file = new java.io.File("E:\\save1.txt");
		fm.create(file);
		fm.showFileInfo(file);
		//fm.delete(file);
	}
	/**
	 * 创建文件的方法
	 */
	public void create(java.io.File file) {
		if(!file.exists()) {
			try {
				file.createNewFile();
				System.out.println("文件已创建！");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	/**
	 * 删除文件
	 */
	public void delete(java.io.File file) {
		if(file.exists()) {
			file.delete();
			System.out.println("文件已经删除！");
		}
	}
	/**
	 * 显示文件信息
	 */
	public void showFileInfo(java.io.File file) {
		if(file.exists()) {
			if(file.isFile()) {
				System.out.println("名称："+file.getName());
				System.out.println("相对路径："+file.getPath());
				System.out.println("绝对路径："+file.getAbsolutePath());
				System.out.println("文件大小："+file.length()+"字节");
			}
			if(file.isDirectory()) {
				System.out.println("文件已经存在！");
			}
		}else {
			System.out.println("文件不存在！");
		}
	}
}

1.2Java的流

​ （1）流的定义：流是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道。一个流是一个输入设备或输出设备的抽象表示。

​ （2）流的分类：

​ 1、按照流的流向进行划分，可以分为输入流和输出流。

​ 输入流：只能从中读取数据，而不能向其中写入数据。（OutputStream和Writer作为基类）

​ 输出流：只能向其中写入数据，而不能从中读取数据。（InputStream和Reader作为基类）

​ 2、按照所操作的数据单元的不同，流又可划分字节流和字符流。

​ 字节流操作的最小数据单元为8位的字节。

​ 字符流操作的最小数据单元为16为的字符。

1.3读写文本文件

1.3.1使用字节流读取文本文件

​ （1）字节输入流InputStream类

​ 字节输入流InputStream的作用就是将文件中的数据输入到内部存储器中。常用的方法如下：

方法名称	说明
int read()	读取一个 字节数据
int read(byte[] b)	将数据读取到字节数据中
int read(byte[] b,int off,int len)	从输入流中读取最多len长度的字节，保存到字节数组b中，保存的位置从off开始
void close()	关闭输入流
int available()	返回输入流读取的估计字节数

​ （2）字节输入流FileInputStream类

​ 我们通常使用InputStream的子类FileInputStream类来实现文本文件内容的读取。语法：

	File file = new File("C:\\test.txt");
	InputStream fileObject = new FileInputStream(file);

​ （3）使用FileInputStream读取文件

​ 1、引入相关类

import java.io.*;

​ 2、创建一个文件输入流的对象

InputStream fileObject = new FileInputStream("C:\\test.txt");

​ 3、利用文件输入流的方法读取文本文件的数据

fileObject.avaiable();//可读取的字节数
fileObject.read();//读取文件的数据

​ 4、关闭文件输入流的对象

fileObject.close();

​ 举例：

public class FileInputStreamTest {
	public static void main(String[] args) {
		//声明流对象
		FileInputStream fis =null;
		try {
			fis = new FileInputStream("E:\\save.txt");
			int data;
			System.out.println("可读取的字节数："+fis.available());
			System.out.print("文件内容：");
			//循环读取数据
			while((data=fis.read())!=-1) {
				System.out.print((char)data+"");
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(fis!=null) {
					fis.close();
				}
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}

1.3.2使用字节流写文本文件

​ （1）字节输出流OutputStream类

​ 字节输出流OutputStream类的作用是把内存的数据输出到文件中，常用方法如下：

方法名称	说明
void write(int c)	写入一个字节数据
void write(byte[] buf)	写入数据buf的所有字节
void write(byte[] b,int off,int len)	将字节数组中从off位置开始，长度为len的字节数据输出带输出流中
void close()	关闭输出流

​ （2）字节输出流FileOutputStream类

​ 我们通常使用OutputStream的子类FileOutputStream类来实现文本文件内容的写入。语法：

File file = new File("C:\\test.txt");
FileOutputStream fos = new FileOutputStream(file);

​ （3）使用FileOutputStream写入文件

​ 1、引入相关类

import java.io.*;

​ 2、创建一个文件输入流的对象

OutputStream fos = new FileOutputStream("C:\\test.txt");

​ 3、利用文件输出流的方法写入数据到文本文件

String str ="好好学习！";
byte[] words =str.getBytes();
//利用write方法将数据写入文件中
fos.write(words,0,words.length);

​ 4、关闭文件输出流的对象

fileObject.close();

​ 举例：

public class FileOutputStream {
	public static void main(String[] args) {
		java.io.FileOutputStream fos=null;
		try {
			String s ="好好学习Java";
			byte[] words =s.getBytes();//字节数组
			//创建流对象追加方式写入文件
			fos= new java.io.FileOutputStream("E:save.txt",true);
			//写入文件
			fos.write(words,0,words.length);
			System.out.println("save文件已经更新！");
		} catch (IOException e) {
			System.out.println("创建文件出错！");
		}finally {
			try {
				if(fos!=null) {
					fos.close();
				}
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}

1.3.3使用字符流读取文本文件

​ （1）字符输入流Reader类

​ Reader类是读取字符流的抽象类，常用方法如下：

​

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

​ （2）字符输入流FileReader类

​ FileReader类是Reader类的子类，语法：

Reader fr = new FileReader（"C:\\\test.txt"）;

​ （3）使用FileReader读取文件

​ 1、引入相关类

import java.io.*;

​ 2、创建一个FileReader的对象

Reader fr = new FileReader("C:\\test.txt");

​ 3、利用文件输入流的方法读取文本文件的数据

int.read();//读取单个字符

​ 4、关闭相关流的对象

fr.close();

​ 举例：

public class FileReader {
	public static void main(String[] args) {
		java.io.Reader fr =null;
		StringBuffer sbf=null;
		try {
			fr = new java.io.FileReader("E:\\简介.txt");
			char ch[] = new char[1024];//创建字符数组作为中转站
			sbf = new StringBuffer();
			int length =fr.read(ch);//将字符读出
			//循环读取并追加字符
			while((length!=-1)) {
				sbf.append(ch);//追加
				length=fr.read();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fr!=null) {
					fr.close();
				}
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}

​ （4）字符输入流BufferedReader类

​ BufferedReader类是Reader类的子类，它与FileReader类的区别在于BufferedReader类带有缓冲区。语法：

Reader fr = new FileReader("C:\\test.txt");
BufferedReader br = new BufferedReader(fr);

​ （5）使用FileReader和BufferedReader读取文本文件

​ 1、引入相关类

import java.io.*;

​ 2、创建一个BufferedReader的对象

Reader fr = new FileReader("C:\\test.txt");
BufferedReader br = new BufferedReader(fr);

​ 3、利用BufferedReader类的方法读取文本文件的数据

br.read();//读取一行数据返回字符串

​ 4、关闭相关流的对象

br.close();
fr.close();

​ 举例：

public class BufferedReader {
	public static void main(String[] args) {
		java.io.FileReader fr=null;
		java.io.BufferedReader br=null;
		try {
			//创建一个FileReader对象
			fr = new FileReader("E:\\save.txt");
			//创建一个BufferedReader对象
			br = new java.io.BufferedReader(fr);
			//读取一行数据
			String line =br.readLine();
			while(line!=null) {
				System.out.println(line);
				line=br.readLine();
			}
		} catch (IOException e) {
			System.out.println("文件不存在！");
		}finally {
			try {
				if(br!=null) {
					br.close();
				}if(fr!=null) {
					fr.close();
				}
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}

1.3.4使用字符流写文本文件

​ （1）字符输出流Writer类

​ Writer类是向文件写入数据的字符流，常用方法如下：

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

​ （2）字符输出流FileWriter类

​ FileWriter类是Writer的子类，语法：

Writer fr = new FileWriter("C:\\test.txt");

​ （3）使用FileWriter写文本文件

​ 1、引入相关类

import java.io.*;

​ 2、创建一个FileWriter的对象

Writer fr = new FileWriter("C:\\test.txt");

​ 3、利用文件输出流的方法写入数据到文本文件

bw.write("Hello!");

​ 4、关闭文件输出流的对象

bw.flush();//刷新该流的缓冲
fw.close();//关闭此流

​ 举例：

public class FileWriter {
	public static void main(String[] args) {
		java.io.Writer fw=null;
		try {
			//创建一个FileWriter对象
			fw = new java.io.FileWriter("E:\\save.txt");
			//写入信息
			fw.write("我热爱我的团队！");
			fw.flush();//刷新缓冲区
			System.out.println("写入成功！");
		} catch (IOException e) {
			System.out.println("文件不存在！");
		}finally {
			try {
				if(fw!=null) {
					fw.close();
				}
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}

​ （4）字符输出流BufferedWriter类

​ BufferedWriter类是BufferedWriter类的子类，BufferedWriter与BufferedReader的流方向正好相反，BufferedWriter是把一批数据写到缓冲区。语法：

Writer fw = new FileWriter("C:\\test.txt");
BufferedWriter bw = new BufferedWriter(fw);

​ （5）使用BufferedWriter和FileWriter写文本文件

​ 1、引入相关类

import java.io.*;

​ 2、创建一个BufferedWriter的对象

Writer fw = new FileWriter("C:\\test.txt");
BufferedWriter bw = new BufferedWriter(fw);

​ 3、利用BufferedWriter类的方法写文本文件的数据

bw.write("Hello!");

​ 4、关闭相关流的对象

bw.flush();//刷新该流的缓冲
fw.close();//关闭此流

​ 举例：

public class File {
	public static void main(String[] args) {
		java.io.FileWriter fw =null;
		java.io.BufferedWriter bw=null;
		try {
			//创建一个FileWriter对象
			fw = new FileWriter("E:\\save.txt");
			//创建一个BufferedWriter对象
			bw = new BufferedWriter(fw);
			//写入信息
			bw.write("大家好！");
			bw.write("我正在学习BufferedWriter。");
			bw.newLine();
			bw.write("多多指教！");
			bw.newLine();//插入换行
			bw.flush();//刷新
			fw.close();//关闭文件流
			java.io.FileReader fr = new FileReader("E:\\save.txt");
			java.io.BufferedReader br = new BufferedReader(fr);
			String line =br.readLine();
			while(line!=null) {
				System.out.println(line);
				line=br.readLine();
			}
		} catch (IOException e) {
			System.out.println("文件不存在！");
		}finally{
			try {
				if(bw!=null) {
					bw.close();
				}if(fw!=null) {
					fw.close();
				}
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}

1.4二进制文件的读写

1.4.1使用字节流类DataInputStream读二进制文件

​ DataInputStream类是FileInputStream的子类，它是FileInputStream的扩展。

​ 1、引入相关类

import java.io.*;

​ 2、创建一个数据输入流的对象

FileInputStream fis = new FileInputStream("C:\\HelloWorld.class");
DataInputStream dis = new DataInputStream(fis);

​ 3、利用数据输入流的方法读取文本文件的数据

dis.read();//读取数据字节

​ 4、关闭相关流的对象

dis.close();//关闭数据输入流

1.4.1使用字节流类DataOutputStream写二进制文件

​ DataOutputStream类是FileOutputStream的子类，它是FileOutputStream类的扩展。

​ 1、引入相关类

import java.io.*;

​ 2、创建一个数据输入流的对象

FileOutputStream fos = new FileOutputStream("C:\\HelloWorld.class");
DataOutputStream out = new DataOutputStream(fis);

​ 3、利用数据输入流的方法写文本文件的数据

out.write(1);//将指定字节数据写入

​ 4、关闭相关流的对象

out.close();//关闭数据输入流

​ 例如：

public class DataOutputStream {
	public static void main(String[] args) {
		java.io.DataOutputStream out =null;
		java.io.DataInputStream dis=null;
		try {
			//创建输入流对象
			java.io.FileInputStream fis = new FileInputStream("E:\\save.txt");
			dis = new DataInputStream(fis);
			//创建输出流对象
			java.io.FileOutputStream outFile = new FileOutputStream("E:\\save1.txt");
			out = new java.io.DataOutputStream(outFile);
			int temp;
			//读取文件
			while((temp=dis.read())!=-1) {
				out.write(temp);
			}
			System.out.println("成功！");
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(dis!=null) {
					dis.close();
				}if(out!=null) {
					out.close();
				}
			} catch (IOException e2) {
				e2.printStackTrace();
			}
		}
	}
}