Java文件读写操作（file I/O）

最新推荐文章于 2022-10-10 14:36:34 发布

qq_37465004

最新推荐文章于 2022-10-10 14:36:34 发布

阅读量483

点赞数

分类专栏： Java高级特性文章标签： io java 语言

本文链接：https://blog.csdn.net/qq_37465004/article/details/76339117

版权

Java高级特性专栏收录该内容

12 篇文章 0 订阅

订阅专栏

File类(获取文件属性,创建和删除文件):

/**
 * 测试File类获取文件属性,创建和删除文件
 * 
 * @author 30869
 *
 */
public class FileMethods {

	public static void main(String[] args) {
		File file = new File("G:/others/hello.txt");// 创建文件对象，构造器参数为文件路径
		showInfo(file);
		file = new File("G:/others/hello2.txt");
		create(file);
		showInfo(file);
		// delete(file);
	}

	/**
	 * 创建文件
	 * 
	 * @param fiel
	 *            文件对象
	 */
	public static void create(File file) {
		if (!file.exists()) {// 如果不存在
			try {
				file.createNewFile();// 创建此文件
				System.out.println("文件创建成功");
			} catch (IOException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("文件已存在，创建失败");
		}
	}

	/**
	 * 删除文件
	 * 
	 * @param file
	 *            文件对象
	 */
	public static void delete(File file) {
		if (file.exists()) {// 如果文件存在
			if (file.isFile()) {
				file.delete();// 删除文件
				System.out.println("文件已删除");
			}
		} else {
			System.out.println("要删除的文件不存在");
		}
	}

	/**
	 * 输出文件信息
	 * 
	 * @param file
	 *            文件对象
	 */
	public static void showInfo(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("文件不存在");
		}
	}
}

字节输入流：

/**
 * 测试InputStream(字节输入流类)的FileInputStream（文件输入流）
 * 
 * @author 30869
 *
 */
public class TestFileInputstream {

	public static void main(String[] args) throws IOException{
		FileInputStream file = null;//声明字节输入流引用
		try {
			file = new FileInputStream("G:/others/hello.txt");//创建字节输入流对象
			System.out.println("可读取的字节数：" + file.available());
			int data = 0;//存储数据
			System.out.println("文件内容如下：");
			while ((data = file.read()) != -1) {//循环读取文件
				System.out.print((char)data + " ");//输出文件信息
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (file != null) {
				try {
					file.close();//关闭流
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

		}
	}

}

字节输出流：

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 测试OutputStream（字节输出流类）的FIleOutputStream文件输出流
 * 
 * @author 30869
 *
 */
public class TestFileOutputStream {

	public static void main(String[] args) {
		String str = "好好学习 Java";
		byte[] words = str.getBytes();//转换为字节数组，因为FileOutputStream类的write方法需要操作字节数组（写入一字节除外）
		FileOutputStream fos = null;//声明文件输出流引用
		try {
			fos = new FileOutputStream("G:/others/hello.txt", true);//创建文件输出流对象，追加方式写入
			fos.write(words, 0, words.length);//写入所有内容
			System.out.println("文件已更新");
		} catch (IOException e) {
			System.out.println("文件创建时出错");//如果文件不存在，则创建，如果是目录，则抛异常
		} finally {
			try {
				fos.close();//关闭流
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

字符输入流：

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

/**
 * 测试Reader（字符输入流类）的FileReader(文件字符输入流)
 * @author 30869
 *
 */
public class TestFileReader {

	public static void main(String[] args) {
		Reader fr=null;
		char[] ch=new char[10];//容量随意
		StringBuffer sbf=new StringBuffer();
		try{
			fr=new FileReader("G:/others/hello.txt");
			int wordsNo=fr.read(ch);//将文件内容放进了ch字符数组，wordsNo字符数量
			while(wordsNo!=-1){//两种方法避免因为文件超出数组容量出现的错误
//				sbf.append(ch);
//				Arrays.fill(ch, ' ');
//				wordsNo=fr.read(ch);
				 sbf.append(ch,  0, wordsNo);//追加数据到字符串
				wordsNo=fr.read(ch);//再次读取，如果还有数据，循环追加
			}
		}
		catch(FileNotFoundException e){
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}finally {
			try {
				System.out.println(sbf);//打印数据
				fr.close();//关闭流
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

字符输出流：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * 测试Writer(字符输出流)类的FileWriter
 * @author 30869
 *
 */
public class TestFileWriter {

	public static void main(String[] args) {
		Writer writer=null;//声明Writer引用
		try {
			writer=new FileWriter("G:/others/hello.txt");//创建FileWriter对象
			writer.write("我爱我的团队！");//写入数据
			writer.flush();//刷新缓冲区
			System.out.println("信息写入成功");
		} catch (IOException e) {
			System.out.println("文件不存在");
		}finally{
			if(writer!=null){
				try {
					writer.close();//关闭流
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

缓冲字符输入流：

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

/**
 * 测试BufferedReader 同样继承自Reader,与FileReader的区别是BufferedReader类带有缓冲区
 * 
 * @author 30869
 *
 */
public class TestBufferedReader {

	public static void main(String[] args) {
		FileReader fr = null;//声明FileReader引用
		BufferedReader bfr = null;//声明BufferedReader引用
		try {
			fr = new FileReader("G:/others/hello.txt");//创建FileReader对象
			bfr = new BufferedReader(fr);//创建BufferedReader对象,并将fr读取到的内容放进缓冲区对象中
			String line = null;
			while ((line=bfr.readLine()) != null) {//从缓冲区读取一行
				System.out.println(line);//循环读取，并打印
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (fr != null) {//如果流中有数据传输
					fr.close();
				}
				if (bfr != null) {
					bfr.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

缓冲字符输出流：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 测试BufferedWriter具有缓冲区(一般和FileWriter一起用)
 * 
 * @author 30869
 *
 */
public class TestBufferedWriter {

	public static void main(String[] args) {
		FileWriter fw = null;//声明FileWriter引用
		BufferedWriter bw = null;//声明BufferedWriter引用
		try {
			fw = new FileWriter("G:/others/hello.txt");//创建FileWriter对象
			bw = new BufferedWriter(fw);//创建BufferedWriter对象
			bw.write("大家好");//写入数据
			bw.write("我正在学习BufferedWriter");
			bw.newLine();//插入换行
			bw.write("请多多指教！");
			bw.flush();//刷新缓冲区
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fw != null) {
				if (bw != null) {
					try {
						bw.close();
						fw.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}

			}
		}
		FileReader fr=null;//声明FlieReader引用
		BufferedReader br=null;//声明BufferedReader引用
		try{
			fr=new FileReader("G:/others/hello.txt");//创建FileReader对象
			br=new BufferedReader(fr);//创建BufferedReader对象
			String line=br.readLine();//读取数据
			while(line!=null){
				System.out.println(line);//循环读取，输出至控制台
				line=br.readLine();
			}
		}catch(IOException e){
			e.printStackTrace();
		}finally{
			if(fr!=null){
				if(br!=null){
					try {
						fr.close();
						br.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

二进制文件的读写：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 测试二进制文件的读写类DataInputStream/DataOutputStream
 * 测试两者按照与平台无关的方式从流中读写基本数据类型的数据，读写字符串需使用readUTF()/writeUTF()
 * @author 30869
 *
 */
public class TestDataInputStream_DataOutputStream {

	public static void main(String[] args) {
		FileInputStream fis=null;//声明引用
		FileOutputStream fos=null;
		DataInputStream dis=null;
		DataOutputStream dos=null;
		try {
			fis=new FileInputStream("C:\\Users\\30869\\Desktop\\bji01991162.jpg");//创建对象
			dis=new DataInputStream(fis);
			fos=new FileOutputStream("G:/others/2.jpg",true);
			dos=new DataOutputStream(fos);
			int temp;
			while((temp=dis.read())!=-1){//读取的同时向目标文件temp.class写入数据
				dos.write(temp);
			}
			System.out.println("已写入2.jpg");
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try{
				if(fis!=null&&dis!=null&&fos!=null&&dos!=null){
					fis.close();
					dis.close();
					fos.close();
					dos.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}
		}
		
		
		//测试两者按照与平台无关的方式从流中读写基本数据类型的数据
		BufferedInputStream bis=null;//声明缓冲输入流引用，提供了一些方法
		try{
		fis=new FileInputStream("G:/others/hello.txt");
		bis=new BufferedInputStream(fis);
		dis=new DataInputStream(bis);
		System.out.println(dis.readByte());//读取
		System.out.println(dis.readShort());
		System.out.println(dis.readChar());
		System.out.println(dis.readInt());
		System.out.println(dis.readLong());
		System.out.println(dis.readFloat());
		System.out.println(dis.readDouble());
		System.out.println(dis.readBoolean());
		System.out.println(dis.readUTF());
		}catch(IOException e){
			e.printStackTrace();
		}finally {
			try{
			if(fis!=null&&bis!=null&&dis!=null){
				fis.close();
				bis.close();
				dis.close();
				bis.close();
			}
			}catch(IOException e){
				e.printStackTrace();
			}
		}
		BufferedOutputStream bos=null;//声明缓冲输出流引用
		try{
			fos=new FileOutputStream("G:/others/hello2.txt");//目标文件
			bos=new BufferedOutputStream(fos);
			dos=new DataOutputStream(fos);
			dos.writeUTF("你好");
			dos.writeByte('5');
			dos.writeShort(56);
			dos.writeChar('h');
			dos.writeInt(789);
			dos.writeLong(65465456);
			dos.writeFloat((float)5.8);
			dos.writeBoolean(true);
			dos.writeDouble(5.6);
			bos.flush();//刷新缓冲区
			System.out.println("已写入");
			}catch(IOException e){
				e.printStackTrace();
			}finally {
				try{
				if(fis!=null&&bis!=null&&dis!=null){
					fis.close();
					bis.close();
					dis.close();
					bos.close();
				}
				}catch(IOException e){
					e.printStackTrace();
				}
			}
	}

}

对象序列化和反序列化：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * 测试对象输出流ObjectOutputStream向文件写入对象信息（对象类必须是实现了Serializable序列化接口）
 * 测试反序列化重新构建对象ObjectInputStream
 * 
 * @author 30869
 *
 */
public class TestObjectOutputStream {
	
	public static void main(String[] args) {
		ObjectOutputStream oos = null;// 创建对象输出流引用
		List<Student> students = new ArrayList<Student>();// 利用集合保存对象信息
		students.add(new Student("李林", 23));
		students.add(new Student("杨英", 19));
		students.add(new Student("王五", 30));
		try {
			oos = new ObjectOutputStream(new FileOutputStream("G:/others/hello.txt"));// 创建对象输出流对象
			oos.writeObject(students);// 将集合信息写入文件
			System.out.println("写入对象成功");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (oos != null) {
				try {
					oos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		//反序列化获取文件中的对象信息进行重新构建
		ObjectInputStream ois = null;//对象输入流引用
		try {
			ois = new ObjectInputStream(new FileInputStream("G:/others/hello.txt"));//对象输入流对象
			ArrayList<Student> students2 = (ArrayList<Student>) ois.readObject();//读取并保存到集合
			for (Student student : students2) {//遍历输出集合中对象信息
				System.out.println("姓名：" + student.getName() + "，年龄：" + student.getAge());
			}
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			if (ois != null) {
				try {
					ois.close();
				} catch (IOException e) {
					e.printStackTrace();
				}

			}
		}

	}

}