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();
			}
		}
	}
}
  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值