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

最新推荐文章于 2024-03-18 21:48:16 发布
最新推荐文章于 2024-03-18 21:48:16 发布
阅读量479 收藏
点赞数
分类专栏： Java高级特性 文章标签： io java 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37465004/article/details/76339117
版权

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

			}
		}

	}

}



qq_37465004
关注
专栏目录
Java I/O技术之文件操作详解
09-04
Java I/O技术是Java编程中不可或缺的一部分，它用于处理输入和输出操作，特别是在与文件系统交互时。在Java中，I/O操作的核心是`java.io`包，它提供了丰富的类和接口来支持文件操作和其他形式的数据传输。本文将深入...
JAVA三种文件读写操作，四种文件拷贝操作
m0_71119554的博客
12-16 2949
2.字节流的基本流：一次读写一个字节数组。4.字节缓冲流：一次读写一个字节数组。3.字节缓冲流：一次读写一个字节。四种拷贝方式概述：1.字节流的基本流：一次读写一个字节。这里我们以一次读取10个字节为例。
Java 中如何实现文件的读写操作？（十六）
Dakaring的专栏
05-03 2078
在上面的代码中，我们首先创建了一个File对象，然后使用FileInputStream来读取该文件中的内容。在上面的代码中，我们首先创建了一个File对象，然后使用FileReader将文件转换为字符流，并使用BufferedReader对其进行包装。在上面的代码中，我们首先创建了一个File对象，然后使用FileOutputStream来写入该文件中的内容。在上面的代码中，我们首先创建了一个File对象，然后使用FileWriter将文件转换为字符流，并使用PrintWriter对其进行包装。
Java文件读写（一）基础文件读写的详细操作
weixin_63020134的博客
04-06 3104
类：Spring框架提供的一个用于处理HTTP multipart请求的接口，提供了获取文件输入流的方法，可以直接操作文件的字节流，支持流式处理，适合处理大文件，但是需要依赖Spring框架。类：用于随机访问文件的类，支持对文件的任意位置进行读取和写入操作，可以提高读写效率。是面向字符的，它们会对读取的字节进行编码和解码，可能会导致读取出来的数据不正确。类：一般用它来表示一个文件或目录，文件操作方面只能创建文件、修改文件的属性。，它支持以字节为单位的随机访问，可以在文件中定位、读取或写入任意位置的数据。
Java的文件读写操作
2301_78008478的博客
05-11 6921
那么，如果没有getParentFile(),直接执行a.mkdirs()，就是说，创建“1/2/AAAA.txt”代表的文件夹，也就是“1/2/AAAA.txt/”，在此之后，执行a.createNewFile()，试图创建a文件，然而以a为名的文件夹已经存在了，所以createNewFile()实际是执行失败的。seek函数使用在各函数中，调用非常频繁，上面加重的这行语句根据pos和bufsize确定buf[]对应当前文件的映射位置，用”*”、”/”确定，显然不是一个好方法。
java 文件读取和写入
AgoniTop的博客
09-24 1万+
1.文件名 1.InputStream(字节流) 和Reader(字符流) 2.OutputStream(字节流) 和 Writer(字符流)
Java文件File的使用及I/O的使用
05-27
在Java编程语言中，文件操作是至关重要的，尤其是在处理数据输入和输出(I/...总的来说，理解和掌握Java文件操作和I/O流是成为专业Java开发人员的基础，而熟悉各种框架和技术则能够帮助你更好地应对复杂的软件开发挑战。
Java I/O文件读写/删除/复制等
08-04
Java I/O 文件操作是Java编程中的重要组成部分...以上就是Java I/O在文件读写、删除、复制及权限设置等方面的基本知识点。实际开发中，可以根据具体需求选择合适的方法和类，灵活运用Java I/O API来处理各种文件操作。
Java I/O 操作及优化详细介绍
08-31
Java I/O 操作是Java应用程序与外部数据交互的基础，涵盖了从磁盘文件读写到网络数据传输的各种场景。本文将深入探讨Java I/O的操作及优化技术。 首先，理解I/O的基本概念至关重要。在Java中，I/O是Input/Output的...
java7 新I/O知识点详解
08-25
这一API主要集中在`java.nio`包及其子包中，旨在提高文件操作的性能，增强并发处理，并引入了异步I/O功能。 首先，NIO.2通过全新的`java.nio.file`包，完全替代了传统的`java.io.File`类来处理文件系统交互。新的...
java实现文件的读取创建等操作
11-05
本程序实现功能为：按行检索一个目标文件的内容 在源文件存在的情况下 读取源文件的每一行如果读入的一行是长整形数字 long 则将数字按照# ### ###的格式输出 如果读入的一行是其他类型的数字 则将数字加一输出 如果读入的一行是yyyy MM dd格式的日期 则将日期加一天输出 其他情况 输出读入的前10个字符（不足10个字符的则取全部字符） 如果目标文件不存在 则输出一个上述内容的目标文件（存在的情况下不做任何输出） 确保源文件和目标文件在任何情况下（包含正常 异常）均会被关闭 若是只有换行符的空行 输出该行 ">本程序实现功能为：按行检索一个目标文件的内容 在源文件存在的情况下 读取源文件的每一行如果读入的一行是长整形数字 long 则将数字按照# ### ###的格式输出 如果读入的一行是其他类型的数字 则将数字加一输出 如 [更多]
java读写文件
热门推荐
旭旭1998的博客
02-25 8万+
1、一次性读取整个文件内容 /** * 一次性读取全部文件数据 * @param strFile */ public static void readFile(String strFile){ try{ InputStream is = new FileInputStream(strFile); ...
java中对文件读写操作的几种方式
世上哪有什么岁月静好,不过是有人替你负重前行
03-06 498
如果我们要从一个文件向另一个文件中写数据，那么会有几种方式呢，来看下。
Java 文件处理完全指南：创建、读取、写入和删除文件详细解析
最新发布
BASK2311的博客
03-18 450
文件处理是任何应用程序的重要部分。Java 提供了许多用于创建、读取、更新和删除文件的方法。
Java中的File及I/O流
于歌852的标题
06-15 220
Java中的File及I/O流 File对象 File类代表文件（文件和目录） 存储介质中的文件和目录在Java程序中都是用File类的实例来表示 常用构造方法： public File(String pathname)：以pathname为路径创建File对象 pathname为一个具体路径： 1. 绝对路径 完整的路径 含有其实盘符到最终的目标文件/目录 优点：在当前系统中任何地方都可以直接定位到目标 缺点：不利于移植 2. 相对路径 相对一个参照路径(基准路径) 使用 .
Java文件读写操作（c站最全！一篇就够了）
小庄的博客
07-21 3083
本篇文章对Java的File类，IO流，文件锁进行详细讲解，欢迎来阅读
Java面向对象编程——File I/O
Chen_NC的博客
09-14 943
使用File类操作文件后目录 创建File对象的语法： File file = new File(String pathName); pathName指的是文件路径。 文件路径名中的分隔符可以使用正斜杠“/”，也可以使用反斜杠"\",但必须写成“\\” File类用于访问文件或目录的属性。 File类的常用方法 方法名称 说明 boolean exists() 判断文件或目录是否存在 boolean isFile() 判断是否是文件 boolean isDire.
Java I/O流与文件操作详解
"Java流和文件I/O的学习资料，包括流和文件I/O概览、文本文件I/O、File类、基本的二进制文件I/O以及对象流进行对象I/O的讲解，适合Java初学者和进阶者。" 在Java编程中，I/O（Input/Output）流是处理数据传输的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值