Java OOP File IO章节

最新推荐文章于 2023-03-28 10:51:40 发布

CGT0522

最新推荐文章于 2023-03-28 10:51:40 发布

阅读量333

点赞数

本文链接：https://blog.csdn.net/CGT0522/article/details/105238604

版权

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();
			}
		}
	}
}