Java对文件的写入和读取 (File类详解以及Input,OutputStream用法,注意事项)
Java中,操作文件的类有很多, 核心的部分是File类,InputStream,OutputStream类
File类
我们先来看看 File
类中的常见属性、构造方法和方法
属性
修饰符及类型 | 属性 | 说明 |
---|---|---|
static String | pathSeparator | 依赖于系统的路径分隔符,String 类型的表示 |
static char | pathSeparator | 依赖于系统的路径分隔符,char 类型的表示 |
构造方法
签名 | 说明 |
---|---|
File(File parent, String child) | 根据父目录 + 孩子文件路径,创建一个新的 File 实例 |
File(String pathname) | 根据文件路径创建一个新的 File 实例,路径可以是绝对路径或者相对路径 |
File(String parent, String child) | 根据父目录 + 孩子文件路径,创建一个新的 File 实例,父目录用路径表示 |
方法
修饰符及返回值类型 | 方法签名 | 说明 |
---|---|---|
String | getParent() | 返回 File 对象的父目录文件路径 |
String | getName() | 返回 FIle 对象的纯文件名称 |
String | getPath() | 返回 File 对象的文件路径 |
String | getAbsolutePath() | 返回 File 对象的绝对路径 |
String | getCanonicalPath() | 返回 File 对象的修饰过的绝对路径 |
boolean | exists() | 判断 File 对象描述的文件是否真实存在 |
boolean | isDirectory() | 判断 File 对象代表的文件是否是一个目录 |
boolean | isFile() | 判断 File 对象代表的文件是否是一个普通文件 |
boolean | createNewFile() | 根据 File 对象,自动创建一个空文件。成功创建后返回 true |
boolean | delete() | 根据 File 对象,删除该文件。成功删除后返回 true |
void | deleteOnExit() | 根据 File 对象,标注文件将被删除,删除动作会到 JVM 运行结束时才会进行 |
String[] | list() | 返回 File 对象代表的目录下的所有文件名 |
File[] | listFiles() | 返回 File 对象代表的目录下的所有文件,以 File 对象表示 |
boolean | mkdir() | 创建 File 对象代表的目录 |
boolean | mkdirs() | 创建 File 对象代表的目录,如果必要,会创建中间目录 |
boolean | renameTo(File dest) | 进行文件改名,也可以视为我们平时的剪切、粘贴操作 |
boolean | canRead() | 判断用户是否对文件有可读权限 |
boolean | canWrite() | 判断用户是否对文件有可写权限 |
注意,File类并不是给一个路径得到的就一定是文件 ,还有可能是一个目录!因此存在isDirectory() / isFile()
方法来进行判断是否是目录/ 文件.
举一些用例:
import java.io.File;
import java.io.IOException;
public class Demo1 {
public static void main(String[] args) throws IOException {
//绝对路径
File f = new File("e:/test.txt");
//获取文件父目录
System.out.println(f.getParent()); //e:\
//获取到文件名
System.out.println(f.getName()); //test.txt
//获取到文件路径
System.out.println(f.getPath()); //e:\test.txt
//获取到绝对路径
System.out.println(f.getAbsolutePath()); //e:\test.txt
//获取绝对路径
System.out.println(f.getCanonicalPath()); // E:\test.txt
System.out.println("==============");
//构造一个相对路径文件
File f2 = new File("./test.txt");
//获取文件父目录
System.out.println(f2.getParent()); // .
//获取到文件名
System.out.println(f2.getName()); // test.txt
//获取到文件路径
System.out.println(f2.getPath()); // .\test.txt
//获取到绝对路径
System.out.println(f2.getAbsolutePath()); // D:\HaoXiangsWareHouse\JavaCode\blogProject\.\test.txt
//获取绝对路径
System.out.println(f2.getCanonicalPath()); // D:\HaoXiangsWareHouse\JavaCode\blogProject\test.txt
}
}
运行结果如下:
有两个点需要注意
- 指定一个File的pathName的时候 即使该路径并没有所在的文件 / 目录, 仍然可以指定
上述Demo中pathName 是 “e:/test.txt” , 但是电脑中并没有 test.txt 文件,但是仍然是能够指定的,因此如果需要判断该路径是否有效,
因此需要使用exists()
之后在判断 isDirectory() / isFile()
.
public static void main(String[] args) {
File f2 = new File("e:/test.txt");
File f = new File("./test.txt");
System.out.println(f.exists());
System.out.println(f.isDirectory());
System.out.println(f.isFile());
}
运行结果如下:
-
还有一个注意的点就是当我们写相对路径的时候, 需要搞清楚当前目录位置在哪里,这里的相对目录位置就是项目所在目录即
此处我建立一个 test.txt文件,这样就可以正确的检测出是文件还是目录了.
运行结果如下:
有了两点注意事项之后, 就可以通过相对路径来进行创建文件操作了.
通过File类创建文件
public class Demo3 {
public static void main(String[] args) throws IOException {
File f = new File("./test.txt");
System.out.println(f.exists());
System.out.println("创建文件");
//成功会返回一个Boolean类型
System.out.println(f.createNewFile());
System.out.println("创建文件结束");
System.out.println(f.exists());
}
}
文件当前目录结构如下: (不存在 test.txt文件)
运行结果如下 :
再看目录结构, 就发现 test.txt文件已经被创建好了:
通过File类创建目录
-
创建单级目录 mkdir(); 该方法会在指定目录位置创建一个目录(文件夹)
但是如果中间目录不存在那么就会创建失败
当前项目位置并不存在 aaa/bbb/ccc目录,此时不创建中间目录 aaa/bbb 查看**mkdir()**方法是否会成功
public static void main(String[] args) { File f = new File("./aaa/bbb/ccc"); System.out.println(f.exists()); System.out.println(f.mkdir()); System.out.println(f.isDirectory()); System.out.println(f.exists()); }
运行结果如下:
创建中间目录aaa/bbb后:
可以看到目录ccc创建成功了
-
创建多级目录 mkdirs() 如果中间目录不存在就会直接把中间目录全部创建
JavaEE目录下是没有aaa/bbb/ccc目录的, 观察是否会被创建成功
import java.io.File;
public class Demo5 {
public static void main(String[] args) {
File f = new File("./aaa/bbb/ccc");
System.out.println(f.exists());
System.out.println(f.mkdirs());
System.out.println(f.isDirectory());
System.out.println(f.exists());
}
}
运行结果如下 :
显而易见,目录之前不存在, 后来通过 mkdirs()方法 创建了多级目录之后,目录就已经存在啦.
文件内容的读写 – 数据流
InputStream
InputStream源码如下:
public abstract class InputStream implements Closeable {
// MAX_SKIP_BUFFER_SIZE is used to determine the maximum buffer size to
// use when skipping.
private static final int MAX_SKIP_BUFFER_SIZE = 2048;
public abstract int read() throws IOException;
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}
public int read(byte b[], int off, int len) throws IOException {
if (b == null) {
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int c = read();
if (c == -1) {
return -1;
}
b[off] = (byte)c;
int i = 1;
try {
for (; i < len ; i++) {
c = read();
if (c == -1) {
break;
}
b[off + i] = (byte)c;
}
} catch (IOException ee) {
}
return i;
}
public long skip(long n) throws IOException {
long remaining = n;
int nr;
if (n <= 0) {
return 0;
}
int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
byte[] skipBuffer = new byte[size];
while (remaining > 0) {
nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
if (nr < 0) {
break;
}
remaining -= nr;
}
return n - remaining;
}
public int available() throws IOException {
return 0;
}
public void close() throws IOException {}
public synchronized void mark(int readlimit) {}
public synchronized void reset() throws IOException {
throw new IOException("mark/reset not supported");
}
public boolean markSupported() {
return false;
}
}
方法
InputStream提供了几个关键方法:
修饰符及返回值类型 | 方法签名 | 说明 |
---|---|---|
int | read() | 读取一个字节的数据,返回 -1 代表已经完全读完了 |
int | read(byte[] b) | 最多读取 b.length 字节的数据到 b 中,返回实际读到的数量;-1 代表以及读完了 |
int | read(byte[] b, int off, int len) | 最多读取 len - off 字节的数据到 b 中,放在从 off 开始,返回实际读到的数量;-1 代表以及读完了 |
void | close() | 关闭字节流 |
最常用的就是 read(byte[]b)
方法来进行读取文件内容
但是因为 InputStream是一个抽象类, 因此需要创建它的实现子类来进行文件读写,这里只关心文件读写, 因此使用FileInputStream
FileInputStream的两个构造方法
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.attach(this);
path = name;
open(name);
}
签名 | 说明 |
---|---|
FileInputStream(File file) | 利用 File 构造文件输入流 |
FileInputStream(String name) | 利用文件路径构造文件输入流 |
案例: 假设在项目内创建一个test.txt文件, 文件内容是 hello World !
- 一次读取一个字符的方法
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo2 {
public static void main(String[] args) {
// 用try语句包裹住,这样就可以避免路径非法之类的错误出现
try(InputStream inputStream = new FileInputStream("./src/file/test.txt")) {
//1. 一个一个字符读取
StringBuilder stringBuilder = new StringBuilder();
while (true) {
int b = inputStream.read();
// 说明已经读取完毕
if (b == -1) {
break;
}
stringBuilder.append((char) b);
}
System.out.println(stringBuilder);
}catch (IOException e) {
e.printStackTrace();
}
}
}
-
一次读取多个字符:
可以通过定义一个buffer缓冲区,来进行缓冲字符,当缓冲区满了之后,就返回.
import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; public class Demo2 { public static void main(String[] args) { // 用try语句包裹住,这样就可以避免路径非法之类的错误出现 try(InputStream inputStream = new FileInputStream("./src/file/test.txt")) { String tmp = null; StringBuilder stringBuilder = new StringBuilder(); while (true) { byte [] buffer = new byte[1024]; int len = inputStream.read(buffer); if(len == -1) { break; } tmp = new String(buffer,0,len); stringBuilder.append(tmp); } System.out.println(stringBuilder); }catch (IOException e) { e.printStackTrace(); } } }
运行结果如下
- 通过Scanner来进行字符读取
上述例子中,我们看到了对字符类型直接使用 InputStream 进行读取是非常麻烦且困难的,所以,我们使用一种我们之前比较熟悉的类来完成该工作,就是 Scanner 类。
构造方法 | 说明 |
---|---|
Scanner(InputStream is, String charset) | 使用 charset 字符集进行 is 的扫描读取 |
// scanner读取Input内容
try(InputStream inputStream = new FileInputStream("./src/file/test.txt")) {
// 指定输入流 和 字符集
Scanner scanner = new Scanner(inputStream,"utf-8");
while (true) {
if (!scanner.hasNextLine()) {
break;
}
String s = scanner.nextLine();
System.out.println(s);
}
}catch (IOException e) {
e.printStackTrace();
}
运行结果如下:
OutputStream
源码如下:
package java.io;
public abstract class OutputStream implements Closeable, Flushable {
public abstract void write(int b) throws IOException;
public void write(byte b[]) throws IOException {
write(b, 0, b.length);
}
public void write(byte b[], int off, int len) throws IOException {
if (b == null) {
throw new NullPointerException();
} else if ((off < 0) || (off > b.length) || (len < 0) ||
((off + len) > b.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}
for (int i = 0 ; i < len ; i++) {
write(b[off + i]);
}
}
public void flush() throws IOException {
}
public void close() throws IOException {
}
}
方法
修饰符及返回值类型 | 方法签名 | 说明 |
---|---|---|
void | write(int b) | 写入要给字节的数据 |
void | write(byte[] b) | 将 b 这个字符数组中的数据全部写入 os 中 |
int | write(byte[] b, int off, int len) | 将 b 这个字符数组中从 off 开始的数据写入 os 中,一共写 len 个 |
void | close() | 关闭字节流 |
void | flush() | 重要:我们知道 I/O 的速度是很慢的,所以,大多的 OutputStream 为了减少设备操作的次数,在写数据的时候都会将数据先暂时写入内存的一个指定区域里,直到该区域满了或者其他指定条件时才真正将数据写入设备中,这个区域一般称为缓冲区。但造成一个结果,就是我们写的数据,很可能会遗留一部分在缓冲区中。需要在最后或者合适的位置, 调用 flush(刷新)操作,将数据刷到设备中。 |
说明:
OutputStream 同样只是一个抽象类,要使用还需要具体的实现类。我们现在还是只关心写入文件中, 所以使用 FileOutputStream
案例, 在之前的test.txt内添加 Hello Java! 字段
-
每次写一个字符
没有执行前test.txt文件内容:
try(OutputStream outputStream = new FileOutputStream("./src/file/test.txt")) { outputStream.write('h'); outputStream.write('e'); outputStream.write('l'); outputStream.write('l'); outputStream.write('o'); outputStream.write(' '); outputStream.write('j'); outputStream.write('a'); outputStream.write('v'); outputStream.write('a'); outputStream.write('!'); } catch (FileNotFoundException e) { throw new RuntimeException(e); } catch (IOException e) { throw new RuntimeException(e); }
此时打开test.txt文件查看内容:
我们发现之前的内容不见了! 因此一定注意,在FileOutputStream内,存在两个构造方法的参数
签名 | 说明 |
---|---|
FileOutputStream(File file) | 创建文件输出流以写入由指定的File对象表示的文件。 |
[FileOutputStream](https://docs.oracle.com/javase/7/docs/api/java/io/FileOutputStream.html#FileOutputStream(java.io.File, boolean))(File file, boolean append) | 创建文件输出流以写入由指定的File对象表示的文件。 |
FileOutputStream(String name) | 创建文件输出流以指定的名称写入文件。 |
[FileOutputStream](https://docs.oracle.com/javase/7/docs/api/java/io/FileOutputStream.html#FileOutputStream(java.lang.String, boolean))(String name, boolean append) | 创建文件输出流以指定的名称写入文件。 |
参数:
File file
: 指定输出流文件
String name
:指定输出流文件所在位置
那么 boolean append
的意义是什么呢 , 追溯源码 可以看到:
原来默认append 参数都是false , 也就是如果要对文件输出,那么就是从开头开始, 但是如果添加了 append 参数 , 那么文件就会从末尾开始, 而不是从开头,也就是对文件进行追加内容.
因此 , 我们只需要在代码构造FileOutpurStream的时候 指定append 参数为true即可实现追加内容的效果:
try(OutputStream outputStream = new FileOutputStream("./src/file/test.txt",true)) {
...
}
结果:
-
一个写多个字符
同理, 只需要创建一个缓冲区即可:
try(OutputStream outputStream = new FileOutputStream("./src/file/test.txt",true)) { byte [] buffer = new byte[]{'h','e','l','l','o',' ','j','a','v','a'}; outputStream.write(buffer); } catch (IOException e) { .... }
结果如下:
-
写入中文
try(OutputStream outputStream = new FileOutputStream("./src/file/test.txt",true)) { String s = "你好Java!"; byte [] buffer = s.getBytes("utf8"); // 指定编码集 outputStream.write(buffer); } catch (FileNotFoundException e) { throw new RuntimeException(e); } catch (IOException e) { throw new RuntimeException(e); }
运行结果如下:
如此发现,使用FileOutputStream来进行写入操作有些繁琐,因为每次都需要一个一个字节指定,有没有更简单的方法呢?
-
肯定是有的,这里就可以使用PrinterWriter 来进行包裹流 来进行输出.
PrintWriter 类中提供了我们熟悉的 print/println/printf 方法.
try(OutputStream outputStream = new FileOutputStream("./src/file/test.txt")) {
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println("HelloJava!!");
printWriter.printf("hello Java!\n");
printWriter.print("Hello,Java~");
//这里一定要手动刷新缓冲区!, 因为缓冲区没有满printWritter不会输出到文件
printWriter.flush();
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
运行结果 :
注意,这里使用printWriter的时候,一定要手动刷新缓冲区
.flush缓冲区
缓冲区存在的意义就是为了提高效率,
在计算机中尤其重要,CPU读取内存的速度大大高于硬盘,需要写数据到硬盘上,与其一次写一点,分多次写, 不如把一些数据攒一堆(这一堆数据在内存中保存的,这块内存就叫做缓冲区) 统一一次写完.
读操作也是类似, 与其一次读一点,分多次读,不如一次性读一堆数据, 再慢慢消化.
例如: 写数据的时候,需要把数据写到缓冲区里面, 然后再统一写在硬盘.
如果当前缓冲区已经写满了, 就直接出发写硬盘操作,
但是如果当前缓冲区还没满 ,也想提前写硬盘, 此时就可以通过flush来手动"刷新缓冲区";
更多推荐
所有评论(0)