Java文件IO操作及案例
Posted 愿荣
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java文件IO操作及案例相关的知识，希望对你有一定的参考价值。
文章目录
一. 文件概述
1. 狭义和广义上的文件
平时我们所提到的文件, 常见的比如 .jpg,.txt, .mp3, .mp4这些, 还有放置这些格式文件的文件夹, 像这些文件都是存储在硬盘上的格式文件或者目录(文件夹), 这些就是狭义上的文件.
而在计算机中文件是一个广义的概念, 广义上的文件泛指计算机中很多的软件硬件资源, 操作系统把许多软硬件资源抽象成了文件, 按照文件的方式来进行统一管理, 比如网络设备中的网卡, 操作系统将网卡也抽象成了一种 “文件”, 以简化程序的开发, 除了网卡, 还有我们所使用的键盘和显示器等也被操作系统抽象为了文件.
而在下面的内容中, 只涉及到狭义的文件.
2. 文件的分类
常见的许多格式文件(如word, execl, 图片, 音频, 视频…), 整体可以归纳到两类中：
- 文本文件(存放的是文本, 字符串), 由字符构成, 都是指定字符集编码表里的数据.
- 二进制文件(存放的是二进制数据), 可以存放任何想存放的数据.
文本文件使用记事本打开里面显示的是正常的文本内容, 而二进制文件使用记事本打开里面大概率是会乱码的, 实际写代码的时候,这两类文件的处理方式略有差别.
3. 文件的路径
每个文件, 在硬盘上都有一个具体的 “路径”, 文件的路径包括两种, 一种是绝对路径, 以盘符(C:或者D:)开头, 另一种是相对路径, 以.或..开头的路径, 相对路径是基于当前所在目录(工作目录)来说的, 使用/(在windows上也可以使用\\, 但是更建议使用的是/, 使用\\在字符串中容易被解析为转义字符)来分割不同的目录级别.
以C:/Program Files/Java/jdk1.8.0_192/bin目录为例, 以该路径为工作目录, 假设我们要在bin文件夹中找到javac.exe文件, 则使用相对路径表示为./javac.exe, 这里的.就表示当前所在目录的路径C:/Program Files/Java/jdk1.8.0_192/bin, 而使用绝对路径表示就更清晰了C:/Program Files/Java/jdk1.8.0_192/bin/javac.exe.
还是以C:/Program Files/Java/jdk1.8.0_192/bin目录为工作目录, 我们要表示与bin文件夹在同一目录中的src.zip文件, 我们可以使用..表示工作目录的父路径C:/Program Files/Java/jdk1.8.0_192, 该文件的相对路径为../src.zip, 绝对路径为C:/Program Files/Java/jdk1.8.0_192/src.zip.
二. 针对文件系统的操作
针对文件系统的操作, 主要是文件/目录的创建和删除, 文件的重命名等.
Java标准库中提供了一个File类, 能够完成对某一路径上的文件进行操作.
1. File类的属性和构造
File类位于import java.io包下, 该类相当于一个抽象的文件路径, 能够在指定的路径中进行文件的创建, 删除, 修改文件等, 但是不能对文件的内容进行操作.
下面先来介绍File类中的常见属性和方法.
🎯File类的属性:
| 修饰符及类型 | 属性 | 说明 |
|---|---|---|
| public static final String | pathSeparator | 依赖于系统的路径分隔符(/或者\\), String类型的表示. |
| public static final char | pathSeparatorChar | 依赖于系统的路径分隔符(/或者\\), char类型的表示. |
🎯File类的构造方法:
| 方法 | 说明 |
|---|---|
| File(File parent, String child) | 根据父文件对象 + 孩子文件路径, 创建文件 |
| File(String path name) | 根据一个文件路径去创建文件 |
| File(String parent, String child) | 根据父目录(路径) + 孩子路径，创建文件 |
File类实例对象就是表示一个文件路径, 上面构造方法的参数中涉及到的String表示的路径, 可以是绝对路径, 也可以是相对路径; 如果通过绝对路径创建文件的实例对象, 那么就是在所给的绝对路径目录下进行相关的文件操作, 而如果是相对路径, 在不同的环境下, 工作目录是不相同的, 比如如果是在控制台的命令行中操作, 则会以在命令行运行程序的目录作为工作目录, 如果在IDEA中操作, 那工作目录默认就是你的当前项目所在的目录.
public static void main(String[] args) throws IOException
File file = new File("D:/test.txt");
要注意的的是上面传入的路径是D:/test.txt, 但实际上在这里并不要求在在D:/这里真的有个test.txt文件, 后序如果需要使用这个文件但没有的话是可以通过createNewFile方法创建的.
2. File类的获取操作
| 返回值 | 方法 | 说明 |
|---|---|---|
| Sting | getParent() | 返回File对象父目录文件路径 |
| String | getName() | 返回File对象文件名 |
| String | getPath() | 返回File对象文件路径 |
| String | getAbsolutePath() | 返回File对象的绝对路径 |
| String | getCanonicalPath() | 返回File对象修饰过的绝对路径 |
代码示例:
import java.io.File;
import java.io.IOException;
public class TestDemo
public static void main(String[] args) throws IOException
//通过绝对路径字符串创建文件对象, 创建文件对象时不会自动创建文件
File file = new File("D:/test.txt");
//获取当前文件对象的文件名
System.out.println(file.getName());
//获取当前文件的绝对路径字符串
System.out.println(file.getAbsolutePath());
//获取当前文件省略后的绝对路径字符串
System.out.println(file.getCanonicalPath());
//获取当前文件父目录的路径字符串
System.out.println(file.getParent());
//获取当前文件对象构造时所传入的路径字符串
System.out.println(file.getPath());
System.out.println("================");
//通过相对路径字符串创建文件对象
File file2 = new File("./test.txt");
//获取当前文件对象的文件名
System.out.println(file2.getName());
//获取当前文件的绝对路径字符串
System.out.println(file2.getAbsolutePath());
//获取当前文件省略后的绝对路径字符串
System.out.println(file2.getCanonicalPath());
//获取当前文件父目录的路径字符串
System.out.println(file2.getParent());
//获取当前文件对象构造时所传入的路径字符串
System.out.println(file2.getPath());
执行结果:
3. File类的判断操作
| 返回值 | 方法 | 说明 |
|---|---|---|
| boolean | exists() | 判断File对象代表的文件是否真实存在 |
| boolean | isDirectory() | 判断File对象代表的文件是否是一个目录 |
| boolean | isFile() | 判断File对象代表的文件是否是一个普通文件 |
| boolean | isHidden() | 判断File对象代表的文件是否是一个隐藏文件 |
| boolean | isAbsolute() | 判断File对象路径名是否是绝对路径 |
| boolean | canRead() | 判断用户是否对文件有可读权限 |
| boolean | canWrite() | 判断用户是否对文件有可写权限 |
| boolean | canExecute() | 判断用户是否对文件有可执行权限 |
代码示例:
在IDEA的在工作目录下存在一个文件test.txt, 这里使用File来判断该文件的一些相关属性.
import java.io.File;
public class TestDemo1
public static void main(String[] args)
File file = new File("./test.txt");
//判断文件是否存在
System.out.println(file.exists());
//判断File对象的路径是否是绝对路径
System.out.println(file.isAbsolute());
//判断文件是否是一个普通文件
System.out.println(file.isFile());
//判断文件是否是一个目录(文件夹)
System.out.println(file.isDirectory());
//判断文件是否是一个隐藏文件
System.out.println(file.isHidden());
//判断文件是否能够执行/读/写
System.out.println(file.canExecute());
System.out.println(file.canRead());
System.out.println(file.canWrite());
执行结果:
4. 文件的创建和删除
| 返回值 | 方法 | 说明 |
|---|---|---|
| boolean | createNewFile() | 自动创建一个新文件，创建成功返回true |
| boolean | mkdir() | 创建File对象表示的目录 |
| boolean | mkdir() | 创建File对象表示的多级目录 |
| boolean | delete() | 根据File对象删除该文件，删除成功返回true |
| void | deleteOnExist() | 根据File对象，标注该文件将被删除，当JVM运行结束才会执行 |
代码示例:
还是在IDEA默认的工作目录下进行演示, 当前目录中只有之前保留的test.txt文件和项目配置文件.
🍂创建文件演示:
import java.io.File;
import java.io.IOException;
public class TestDemo2
public static void main(String[] args) throws IOException
File file = new File("./abc.txt");
//文件未创建的情况下创建新文件
if (!file.exists())
file.createNewFile();
System.out.println("创建文件成功！");
//创建一个目录(文件夹)
file = new File("./temp");
file.mkdir();
System.out.println("创建目录成功!");
//创建多个目录
file = new File("./aaa/bbb/ccc");
file.mkdirs();
System.out.println("创建多个文件夹成功！");
执行结果:
如果程序运行后工作目录中没有实时看到对应文件或者目录创建的话, 可以右键项目, 然后选择Reload from Disk刷新一下即可.
🍂删除文件演示:
import java.io.File;
public class TestDemo3
public static void main(String[] args)
//删除操作
File file = new File("./test.txt");
file.delete();
执行结果:
关于删除方法中的deleteOnExist()不太好演示, 这里解释一下, 这个方法的功能是在程序退出的时候, 自动删除文件, 当我们在程序中需要用到一些 “临时文件” 的时候, 可以用到这个方法, 保证在程序退出的同时把临时文件给删除掉.
什么时候会用到临时文件的呢, 比如这里打开一个word文档, 在打开的同时就会在同级目录下生成出一个临时文件, 关闭word, 这个临时文件被删除了, 临时文件发挥的功能是实时保存我们实时编辑的内容(尤其是没有保存的内容), 防止我们编辑了很多内容但由于一些问题导致我们没有进行保存, 比如工作一半突然停电了, 东西还没来得及保存, 但由于临时文件中实时保存了我们编辑的内容, 等到再次启动word文档时, 就会提醒我们是否要恢复之前的编辑内容.
5. 其他的常用方法
| 返回值 | 方法 | 说明 |
|---|---|---|
| String[] | list() | 返回File对象目录下所有的文件名 |
| File[] | listFiles() | 返回File对象目录下的所有文件，以File对象的形式表示 |
| boolean | renameTo(File dest) | 对文件进行改名 |
代码示例:
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
public class TestDemo4
public static void main(String[] args) throws IOException
File file = new File("./");
File tmp1 = new File("./aaa");
File tmp2 = new File("./eee");
//获取当前路径目录下所有文件名
System.out.println(Arrays.toString(file.list()));
//将目录aaa更名为eee
System.out.println(tmp1.renameTo(tmp2));
//重新获取当前路径目录下所有文件名
System.out.println(Arrays.toString(file.list()));
执行结果:
三. 对文件内容进行读写
1. IO流对象
针对文件内容的读写, Java标准库中提供了两组类和接口, 分别用来针对两类文件的内容进行读写, 一组是字节流对象, 可以针对二进制文件进行读写, 另外一组是字符流对象, 可以针对文本文件进行读写.
对于二进制文件内容的读写可以使用InputStream(读)和OutputStream(写)来操作, 对于文本文件内容的读写可以使用Reader(读)和Writer(写)来操作, 这四个java提供的标准类都是抽象类, 可以认为不同的输入/输出设备都可以对应一个前面的类, 但这里只关心文件的读写, 我们在使用时使用这几个实现类来创建实例对象即可, 分别对应的是FileInputStream, FileOutputStream, FileReader和FileWriter类.
那么为什么针对文件内容操作这些类叫做 “流对象”? 其实这是一个形象的比喻, 想象一下水流的滔滔不绝, 接水时我们可以选择一次接一点水, 也可以选择一次接很多水; 而我们使用这些类对文件进行读写操作时, 可以一次读一个字节/字符, 也可以一次读多个字节/字符, 就像水流一样, 所以将这些对象叫做流对象; 想象有一个羽毛球筒, 筒里有很多羽毛球, 但羽毛球只能一个一个取, 这就不是流.
对文件进行写操作称为输出流, 对文件进行读操作称为输入流.
还有一个点这里简单说一下, 计算机中的读和写的方向, 是以CPU为中心来看待的, 内存更接近CPU, 而硬盘相较于内存离CPU更远;
数据朝着CPU的方向流, 就是输入, 所以就把数据从硬盘到内存这个过程称为读(input); 数据向远离CPU的方向流向, 就是输出, 所以就把数据从内存到硬盘这个过程称为写(output).
那么下面就介绍具体的使用了, 虽然这里涉及到的类很多, 但在使用时规律性很强, 核心就是四个操作:
- 打开文件(构造对象).
- 读文件(
read), 针对InputStream/Reader. - 写文件(
write), 针对OutputStream/Writer. - 关闭文件(
close).
不过还是有一些需要注意的细节, 具体看下面的内容.
2. 文件的读操作
🍂首先先来看读文件的操作, 读文件涉及到的抽象类和实现类有, 字节流: InputStream, FileInputStream, 字符流: Reader, FileReader.
FileInputStream的构造方法:
| 方法 | 解释 |
|---|---|
| FileInputStream(File file) | 利用 File 构造文件输入流 |
| FileInputStream(String name) | 利用文件路径构造文件输入流 |
InputStream读文件涉及的方法:
| 返回值 | 方法 | 解释 |
|---|---|---|
| int | read() | 读取一个字节的数据, 返回值就是读取到的字节值, 返回 -1 代表已经完全读完了 |
| int | read(byte[] b) | 最多读取 b.length 字节的数据到 b 中，返回实际读到的字节数, -1 代表以及读完了, b是输出型参数 |
| int | read(byte[] b, int off, int len) | 最多读取 len - off 字节的数据到 b 中, 放在从 off 开始，返回实际读到的字节数, -1 代表已经读完了 |
| void | close() | 关闭字节流 |
对于上面无参版本的read()有一个小问题, 它的返回值是读取到的字节值, 那它的返回值按理来说设置为byte就行了, 为什么这里的返回值设置为了int呢?
其实这样设置是为了处理文件读完了情况, 我们知道使用这个方法文件读完了的情况下是返回值是一个-1, 如果使用byte类型作为返回值会出现一个问题, byte能表示的范围是-128到127, 当返回值为-1时区分不了文件是读完了还是读到的字节值就是-1, 而如果将读到一个字节的内容放在更大范围的内存当中(int), 此时读到的byte(-128到127)范围内的值就可以在int范围内表示为0到255这样的值, 此时返回-1就表示读到了文件的末尾了.
FileReader的构造方法:
| 方法 | 解释 |
|---|---|
| FileReader(File file) | 创建字符输人流与源文件对象接通 |
| FileReader(File file,Charset charset) | 创建字符输人流与源文件对象接通,指定字符集 |
| FileReader(String fileName) | 创建字符输人流与源文件路径接通 |
| FileReader(String fileName,Charset charset) | 创建字符输人流与源文件路径接通，指定字符集 |
Reader读文件涉及的方法:
| 返回值 | 方法 | 解释 |
|---|---|---|
| int | read() | 读取一个字符的数据, 返回值就是读取到的字符值, 返回-1代表已经完全读完了 |
| int | read(char[] b) | 最多读取 b.length 个字符的数据到 b 中, 返回实际读到的字符数; -1 代表以及读完了, b是输出型参数 |
| int | read(char[] b, int off, int len) | 最多读取 len - off 个字符的数据到 b 中, 放在从 off 开始，返回实际读到的字符数, -1 代表已经读完了 |
| void | close() | 关闭字节流 |
字符流无参版本的read()返值设置值为int的原因和字节流是类似的.
代码示例:
项目所在的工作目录下有一个abc.txt的文本文件, 该文件中有9个字母aaabbbccc, 使用一个缓冲数组接收数据, 使用字节流对象读取, 得到的结果就是它们的Unicode码值(Unicode码中包含ASCll码), 如果要去验证对照, 首先要知道你使用的编译器是按照什么样的方式编码, 然后再去对应码表查询对照, IDEA默认是utf8(utf8是Unicode的实现方式之一), 如果你这里的文件是其他编码, 比如gbk, 就需要去和abk码表去对照, 使用字符流对象读取, 得到的就是文件中的字符.
要注意理解下面代码中read方法的使用, 参数是一个数组, 这就需要我们提前准备好一个缓冲数组, 把这个数组传入read方法, 让read方法内部针对这个数组进行填充, read会尽可能的把参数传进来的数组给填满, 然后我们需要对数组中读到的内容进行处理, 如果文件内容没读完的话就循环进行读取再次将数据填充到数组中(会覆盖上一次读取的内容).
而这个缓冲数组存在的意义是为了提高IO操作的效率, 因为访问硬盘/IO设备都是比较耗时的, 而缓冲数组的存在降低了IO的次数.
import java.io.*;
public class TestDemo5
public static void main(String[] args)
try
//以字节为单位读取
InputStream inputStream = new FileInputStream("./abc.txt");
//以字符为单位读取
Reader reader = new FileReader("./abc.txt");
//字节流
while (true)
byte[] bytes = new byte[1024];
int len = inputStream.read(bytes);
if (len == -1)
break;
for (int i = 0; i < len; i++)
System.out.print(bytes[i] + " ");
//关闭文件
inputStream.close();
System.out.println();
//字符流
while (true)
char[] chars = new char[1024];
int len = reader.read(chars);
if (len == -1) break;
for (int i = 0; i < len; i++)
System.out.print(chars[i] + " ");
//关闭文件
reader.close();
catch (FileNotFoundException e)
e.printStackTrace();
catch (IOException e)
e.printStackTrace();
执行结果:
观察结果, 虽说字节流和字符流都可以读取文件内容, 但使用字符流读到的内容明显更直观一些.
文件读取完之后, 要记得关闭文件资源, 在上面的写法中有个问题是如果读取时发生异常就无法及时关闭文件了, 为了能够及时的关闭资源, 我们可以使用finally这个语法, 但更推荐下面的这种写法吗将读写对象定义在try中, 当try代码块执行完毕后会自动执行close关闭文件资源.
import java.io.*;
public class TestDemo6
public static void main(String[] args)
//字节流
try (InputStream inputStream = new FileInputStream("./abc.txt"))
while (true)
byte[] bytes = new byte[1024];
int len = inputStream.read(bytes);
if (len == -1)
break;
for (int i = 0; i < len; i++)
System.out.print(bytes[i] + " ");
catch (FileNotFoundException e)
e.printStackTrace();
catch (IOException e)
e.printStackTrace();
System.out.println();
//字符流
try (Reader reader = new FileReader("./abc.txt");)
while (true)
char[] chars = new char[1024];
int len = reader.read(chars);
if (len == -1)
break;
for (int i = 0; i < len; i++)
System.out.print(chars[i] + " ");
catch (FileNotFoundException e)
e.printStackTrace();
catch (IOException eJava知识点--IO流（上）
Java知识点--IO流（上）
-
一、文件
1、文件的含义
文件是保存数据的地方，比如word文档，txt文本文件，视频，图片等都是文件。
2、文件流
文件在程序中是以流的形式来操作的。
输入流：数据从文件到程序（内存）的路径。（在程序中读取文件数据）
输出流：数据从程序（内存）到文件的路径。（在程序中将数据写入文件）
二、常用的文件操作
1、创建文件对象相关构造器和方法
相关构造器：
new File(String filePath) 根据路径创建File对象
new File(File parent,String child) 根据父目录文件+子路径创建File对象
new File(tring parent,String child) 根据父目录+子路径创建File对象
方法：
createNewFile 创建新文件
2、创建文件案例演示（三种创建方法）
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;
public class FileCreate
public static void main(String[] args)
@Test
public void create01()
String filePath = "e:\\\\news1.txt";
File file = new File(filePath);
try
file.createNewFile();
System.out.println("文件创建成功");
catch (IOException e)
e.printStackTrace();
@Test
public void create02()
File parentFile = new File("e:\\\\");
String fileName = "news2.txt";
File file = new File(parentFile, fileName);
try
file.createNewFile();
System.out.println("文件创建成功");
catch (IOException e)
e.printStackTrace();
@Test
public void create03()
String parentPath = "e:\\\\";
String fileName = "news3.txt";
File file = new File(parentPath, fileName);
try
file.createNewFile();
System.out.println("文件创建成功");
catch (IOException e)
e.printStackTrace();
3、获取文件相关信息的方法
“文件名字” — getName()
“文件绝对路径” — getAbsolutePath()
“文件父级目录” — getParent()
“文件大小(字节)” — length()
“文件是否存在” — exists()
“是不是一个文件” — isFile()
“是不是一个目录” — isDirectory()
4、获取文件相关信息方法案例演示
import org.junit.jupiter.api.Test;
import java.io.File;
public class FileInformation
public static void main(String[] args)
@Test
public void info()
File file = new File("e:\\\\news1.txt");
System.out.println("文件名字" + file.getName());
System.out.println("文件绝对路径" + file.getAbsolutePath());
System.out.println("文件父级目录" + file.getParent());
System.out.println("文件大小(字节)" + file.length());
System.out.println("文件是否存在" + file.exists());
System.out.println("是不是一个文件" + file.isFile());
System.out.println("是不是一个目录" + file.isDirectory());
5、目录的操作与删除
mkdir()：创建一级目录
mkdirs()：创建多级目录
delete()：删除目录或文件
6、应用案例演示
(1)判断e:\\news1.txt是否存在，如果存在就删除
(2)判断d:\\demo02是否存在，如果存在就删除，否则提示不存在
(3)判断d:\\demo\\a\\b\\c是否存在，如果存在就提示存在，否则创建
import org.junit.jupiter.api.Test;
import java.io.File;
public class Directory_
public static void main(String[] args)
@Test
public void m1()
String pathName = "e:\\\\news1.txt";
File file = new File(pathName);
if (file.exists())
if (file.delete())
System.out.println("删除成功");
else
System.out.println("删除失败");
else
System.out.println("该文件不存在");
@Test
public void m2()
String pathName = "d:\\\\demo02";
File file = new File(pathName);
if (file.exists())
if (file.delete())
System.out.println("删除成功");
else
System.out.println("删除失败");
else
System.out.println("该目录不存在");
@Test
public void m3()
String directoryPath = "d:\\\\demo\\\\a\\\\b\\\\c";
File file = new File(directoryPath);
if (file.exists())
System.out.println(directoryPath + "已经存在");
else
if (file.mkdirs())
System.out.println(directoryPath + "创建成功");
else
System.out.println(directoryPath + "创建失败");
三、IO 流原理及流的分类
1、Java IO 流原理
(1) I／O是Input／Output的缩写，l／O技术是非常实用的技术，用于处理数据传输。如读／写文件，网络通讯等。
(2) Java程序中，对于数据的输入／输出操作以”流（stream）”的方式进行。
(3) java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。
(4) 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
(5) 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。
2、流的分类
按操作数据单位不同分为：字节流（8 bit）二进制文件，字符流（按字符）文本文件
按数据流的流向不同分为：输入流，输出流
按流的角色的不同分为：节点流，处理流／包装流
（抽象基类） 字节流 字符流 输入流 InputStream Reader 输出流 OutputStream Writer
1） Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。
2）由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
四、IO 流体系图
五、FileInputStream 字节输入流
可以用单个字节来读取文件，也可以用字节数组来读取文件。
以字节数组为例：
1、确定文件路径
String filePath = “e:\\hello.txt”;
2、引入FileInputStream
FileInputStream fileInputStream = new FileInputStream(filePath);
3、定义字节数组
byte[] buf = new byte[8];
4、定义读取字节数
int data = 0;
5、读取数据
while ((data = fileInputStream.read(buf)) != -1)
System.out.println(new String(buf, 0, data));
用while循环读取，条件 = -1时说明读取完毕
6、关闭流
fileInputStream.close();
7、完整版
public void readFile02()
String filePath = "e:\\\\hello.txt";
FileInputStream fileInputStream = null;
byte[] buf = new byte[8];
int data = 0;
try
fileInputStream = new FileInputStream(filePath);
while ((data = fileInputStream.read(buf)) != -1)
System.out.println(new String(buf, 0, data));
catch (IOException e)
e.printStackTrace();
finally
try
fileInputStream.close();
catch (IOException e)
e.printStackTrace();
六、FileOutputStream 字节输出流
可以用单个字节来写入文件，也可以用字节数组来写入文件。
以字节数组为例：
1、确定文件路径
String filePath = “e:\\a.txt”;
2、引入FileOutputStream
FileOutputStream fileOutputStream = new FileOutputStream(filePath);//运行时会覆盖上一次的结果
FileOutputStream fileOutputStream = new FileOutputStream(filePath, true); //运行时不会覆盖上一次的结果
3、写入数据
String str = “hello,world!”;
fileOutputStream.write(str.getBytes());
4、关闭流
fileOutputStream.close();
5、完整版
public void writeFile()
String filePath = "e:\\\\a.txt";
FileOutputStream fileOutputStream = null;
try
//运行时会覆盖上一次的结果
fileOutputStream = new FileOutputStream(filePath);
//运行时不会覆盖上一次的结果
fileOutputStream = new FileOutputStream(filePath, true);
//写入单个字符
fileOutputStream.write('H');
//写入字符串
String str = "hello,world!";
//将字符串转成字节数组
fileOutputStream.write(str.getBytes());
//控制写入字符串范围
fileOutputStream.write(str.getBytes(), 0, str.length());
catch (IOException e)
e.printStackTrace();
finally
try
fileOutputStream.close();
catch (IOException e)
e.printStackTrace();
七、用字节流拷贝文件
1、确定原文件与新文件路径
String filePath = “e:\\1.jpg”;
String newFilePath = “d:\\1.jpg”;
2、引入FileInputStream 与 FileOutputStream
FileInputStream fileInputStream = new FileInputStream(filePath);
fileOutputStream fileOutputStream = new FileOutputStream(newFilePath);
3、定义字节数组
byte[] buf = new byte[1024];
4、定义读取字节数
int data = 0;
5、拷贝数据
while ((data = fileInputStream.read(buf)) != -1)
fileOutputStream.write(buf, 0, data);
6、关闭流
fileInputStream.close();
fileOutputStream.close();
7、完整版
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy
public static void main(String[] args)
String filePath = "e:\\\\1.jpg";
String newFilePath = "d:\\\\1.jpg";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try
fileInputStream = new FileInputStream(filePath);
fileOutputStream = new FileOutputStream(newFilePath);
byte[] buf = new byte[1024];
int data = 0;
while ((data = fileInputStream.read(buf)) != -1)
fileOutputStream.write(buf, 0, data);
System.out.println("拷贝成功");
catch (IOException e)
e.printStackTrace();
finally
try
if (fileInputStream != null)
fileInputStream.close();
if (fileOutputStream != null)
fileOutputStream.close();
catch (IOException e)
e.printStackTrace();
八、FileReader 字符输入流
可以用单个字符来读取文件，也可以用字符数组来读取文件。
1、FileReader 相关方法：
（1） new FileReader(File/String)
（2） read：每次读取单个字符，返回该字符，如果到文件末尾返回-1
（3） read（char［］）：批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1
相关API：
（1） new String（char［］）：将char［］转换成String
（2） new String（char［］，off，len）：将char［］的指定部分转换成String
2、以字符数组来读取文件
import java.io.FileReader;
import java.io.IOException;
public class FileReader_
public static void main(String[] args)
String filePath = "e:\\\\story.txt";
FileReader fileReader = null;
char[] chars = new char[100];
int data = 0;
try
fileReader = new FileReader(filePath);
while ((data = fileReader.read(chars)) != -1)
System.out.print(new String(chars, 0, data));
catch (IOException e)
e.printStackTrace();
finally
try
fileReader.close();
catch (IOException e)
e.printStackTrace();
九、FileWriter 字符输入流
1、 FileWriter 常用方法
1） new FileWriter（File／String）：覆盖模式，相当于流的指针在首端
2） new FileWriter（File／String，true）：追加模式，相当于流的指针在尾端
3） write（int）：写入单个字符
4） write（char［］）：写入指定数组
5） write（char［］，off，len）：写入指定数组的指定部分
6） write（string）：写入整个字符串
7） write（string，off，len）：写入字符串的指定部分
相关API： String类： toCharArray：将String转换成char［］
＞注意：
FileWriter使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件！
2、写入文件案例
import java.io.FileWriter;
import java.io.IOException;
public class FileWriter_
public static void main(String[] args)
String filePath = "e:\\\\1.txt";
FileWriter fileWriter = null;
try
fileWriter = new FileWriter(filePath);
fileWriter.write('H');
char[] chars = 'a', 'b', 'c';
fileWriter.write(chars);
fileWriter.write("大事发生".toCharArray(), 0, 2);
fileWriter.write("巅峰时代");
fileWriter.write("法国电视", 0, 3);
catch (IOException e)
e.printStackTrace();
finally
try
fileWriter.close();
catch (IOException e)
e.printStackTrace();
以上是关于Java文件IO操作及案例的主要内容，如果未能解决你的问题，请参考以下文章