Java对文件的写入和读取 (File类详解以及Input,OutputStream用法,注意事项)

Java中,操作文件的类有很多, 核心的部分是File类,InputStream,OutputStream类

文章目录

• File类
• • 通过File类创建文件
  • 通过File类创建目录
• 文件内容的读写 — 数据流
• • InputStream
  • • 方法
  • OutputStream
  • • 方法
    • .flush缓冲区

File类

我们先来看看 File类中的常见属性、构造方法和方法

属性

构造方法

方法

注意,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.txtSystem.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提供了几个关键方法:

最常用的就是 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);}

案例: 假设在项目内创建一个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读取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 {}}

方法

说明:

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内,存在两个构造方法的参数

参数:

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来进行写入操作有些繁琐,因为每次都需要一个一个字节指定,有没有更简单的方法呢” />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来手动”刷新缓冲区”;

  ---