服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|

服务器之家 - 编程语言 - JAVA教程 - 详解Java中的File文件类以及FileDescriptor文件描述类

详解Java中的File文件类以及FileDescriptor文件描述类

2020-05-21 12:12skywangkw JAVA教程

在Java中File类可以用来新建文件和目录对象,而FileDescriptor类则被用来表示文件或目录的可操作性,接下来我们就来详解Java中的File文件类以及FileDescriptor文件描述类

File

File 是“文件”和“目录路径名”的抽象表示形式。
File 直接继承于Object，实现了Serializable接口和Comparable接口。实现Serializable接口，意味着File对象支持序列化操作。而实现Comparable接口，意味着File对象之间可以比较大小；File能直接被存储在有序集合(如TreeSet、TreeMap中)。
1. 新建目录的常用方法
方法1：根据相对路径新建目录。
示例代码如下(在当前路径下新建目录“dir”)：

?
1
2
File dir = new File("dir");
dir.mkdir();

方法2：根据绝对路径新建目录。
示例代码如下(新建目录“/home/skywang/dir”)：

?
1
2
File dir = new File("/home/skywang/dir");
dir.mkdirs();

说明：上面是在linux系统下新建目录“/home/skywang/dir”的源码。在windows下面，若要新建目录“D:/dir”，源码如下：

?
1
2
File dir = new File("D:/dir");
dir.mkdir();

方法3

?
1
2
3
URI uri = new URI("file:/home/skywang/dir");
File dir = new File(uri);
sub.mkdir();

说明： 和“方法2”类似，只不过“方法2”中传入的是完整路径，而“方法3”中传入的是完整路径对应URI。
2. 新建子目录的几种常用方法
例如，我们想要在当前目录的子目录“dir”下，再新建一个子目录。有一下几种方法:
方法1

?
1
2
File sub1 = new File("dir", "sub1");
sub1.mkdir();

说明：上面的方法作用是，在当前目录下 "dir/sub1"。它能正常运行的前提是“sub1”的父目录“dir”已经存在！
方法2

?
1
2
File sub2 = new File(dir, "sub2");
sub2.mkdir();

说明：上面的方法作用是，在当前目录下 "dir/sub2"。它能正常运行的前提是“sub2”的父目录“dir”已经存在！
方法3

?
1
2
File sub3 = new File("dir/sub3");
sub3.mkdirs();

说明：上面的方法作用是，在当前目录下 "dir/sub3"。它不需要dir已经存在，也能正常运行；若“sub3”的父母路不存在，mkdirs()方法会自动创建父目录。
方法4

?
1
2
File sub4 = new File("/home/skywang/dir/sub4");
sub4.mkdirs();

说明：上面的方法作用是，新建目录"/home/skywang/dir/sub3"。它不需要dir已经存在，也能正常运行；若“sub4”的父母路不存在，mkdirs()方法会自动创建父目录。
方法5

?
1
2
3
URI uri = new URI("file:/home/skywang/dir/sub5");
File sub5 = new File(uri);
sub5.mkdirs();

说明： 和“方法4”类似，只不过“方法4”中传入的是完整路径，而“方法5”中传入的是完整路径对应URI。
3. 新建文件的几种常用方法
例如，我们想要在当前目录的子目录“dir”下，新建一个文件。有一下几种方法
方法1

?
1
2
3
4
5
6
7
try {
  File dir = new File("dir");  // 获取目录“dir”对应的File对象
  File file1 = new File(dir, "file1.txt");
  file1.createNewFile();
} catch (IOException e) {
  e.printStackTrace();
}

说明：上面代码作用是，在“dir”目录(相对路径)下新建文件“file1.txt”。
方法2

?
1
2
3
4
5
6
try {
  File file2 = new File("dir", "file2.txt");
  file2.createNewFile();
} catch (IOException e) {
  e.printStackTrace();
}

说明：上面代码作用是，在“dir”目录(相对路径)下新建文件“file2.txt”。
方法3

?
1
2
3
4
5
6
try {
  File file3 = new File("/home/skywang/dir/file3.txt");
  file3.createNewFile();
} catch (IOException e) {
  e.printStackTrace();
}

说明：上面代码作用是，下新建文件“/home/skywang/dir/file3.txt”(绝对路径)。这是在linux下根据绝对路径的方法，在windows下可以通过以下代码新建文件"D:/dir/file4.txt"。

?
1
2
3
4
5
6
try {
  File file3 = new File("D:/dir/file4.txt");
  file3.createNewFile();
} catch (IOException e) {
  e.printStackTrace();
}

方法4

?
1
2
3
4
5
6
7
try {
  URI uri = new URI("file:/home/skywang/dir/file4.txt");
  File file4 = new File(uri);
  file4.createNewFile();
} catch (IOException e) {
  e.printStackTrace();
}

说明：
和“方法3”类似，只不过“方法3”中传入的是完整路径，而“方法4”中传入的是完整路径对应URI。
4. File API使用示例
关于File中API的详细用法，参考示例代码(FileTest.java)：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.Calendar;
import java.text.SimpleDateFormat;
 
public class FileTest {
 
  public static void main(String[] args) {
    testFileStaticFields() ;
  testFileDirAPIS() ;
  }
 
  public static void testFileStaticFields() {
    // 打印 路径分隔符":"
    System.out.printf("File.pathSeparator=\"%s\"\n", File.pathSeparator);
    // 打印 路径分隔符':'
    System.out.printf("File.pathSeparatorChar=\"%c\"\n", File.pathSeparatorChar);
    // 打印 分隔符"/"
    System.out.printf("File.separator=\"%s\"\n", File.separator);
    // 打印 分隔符'/'
    System.out.printf("File.separatorChar=\"%c\"\n", File.separatorChar);
  }
 
  public static void testFileDirAPIS() {
    try {
    // 新建目录 "dir"
    File dir = new File("dir");
    dir.mkdir();
 
    // 方法1：新建目录 "dir/sub1"。父目录“dir”必须已经存在！
    File sub1 = new File("dir", "sub1");
    sub1.mkdir();
    // 方法2：新建目录 "dir/sub2"。父目录“dir”必须已经存在！
    File sub2 = new File(dir, "sub2");
    sub2.mkdir();
    // 方法3：新建目录 "dir/sub3"。mkdirs()会自动创建不存在的父目录。
    File sub3 = new File("dir/sub3");
    sub3.mkdirs();
    // 方法4：新建目录 "dir/sub4"。根据“绝对路径”创建，前面3个方法都是根据“相对路径”创建。
    String dirPath = dir.getAbsolutePath();  // 获取“dir”的绝对路径
    String sub4AbsPath = dirPath + File.separator + "sub4";  // File.separator是分隔符"/"
    File sub4 = new File(sub4AbsPath);
    sub4.mkdirs();
    // 方法5：新建目录 "dir/sub5"。根据uri
    String uri_sub5_path = "file:"+ dirPath + File.separator + "sub5";
    URI uri_sub5 = new URI(uri_sub5_path);
    File sub5 = new File(uri_sub5);
    sub5.mkdirs();
 
    // 方法1：新建文件 "dir/l1_normal.txt"
    File l1_normal = new File(dir, "l1_normal.txt");
    l1_normal.createNewFile();
    // 方法2：新建文件 "dir/.l1_hide.txt"。
    File l1_hide = new File("dir", ".l1_hide.txt"); // 在linux中, "."开头的文件是隐藏文件。
    l1_hide.createNewFile();
    // 方法3：新建文件 "dir/l1_abs.txt"。
    String dirAbsPah = dir.getAbsolutePath();  // 获取dir的绝对路径
    String l1_abs_path = dirAbsPah+File.separator+"l1_abs.txt";
    File l1_abs = new File(l1_abs_path);
    l1_abs.createNewFile();
    //System.out.printf("l1_abs_path=%s\n", l1_abs_path);
    //System.out.printf("l1_abs path=%s\n", l1_abs.getAbsolutePath());
    // 方法4：新建文件 "dir/l1_uri.txt"。根据URI新建文件
    String uri_path = "file:"+ dirAbsPah + File.separator + "l1_uri.txt";
    URI uri_l1 = new URI(uri_path);
    //System.out.printf("uri_l1=%s\n", l1_abs.getAbsolutePath());
    File l1_uri = new File(uri_l1);
    l1_uri.createNewFile();
 
    // 新建文件 "dir/sub/s1_normal"
    File s1_normal = new File(sub1, "s1_normal.txt");
    s1_normal.createNewFile();
 
    System.out.printf("%30s = %s\n", "s1_normal.exists()", s1_normal.exists());
    System.out.printf("%30s = %s\n", "s1_normal.getName()", s1_normal.getName());
    System.out.printf("%30s = %s\n", "s1_normal.getParent()", s1_normal.getParent());
    System.out.printf("%30s = %s\n", "s1_normal.getPath()", s1_normal.getPath());
    System.out.printf("%30s = %s\n", "s1_normal.getAbsolutePath()", s1_normal.getAbsolutePath());
    System.out.printf("%30s = %s\n", "s1_normal.getCanonicalPath()", s1_normal.getCanonicalPath());
    System.out.printf("%30s = %s is \"%s\"\n", "s1_normal.lastModified()", s1_normal.lastModified(), getModifyTime(s1_normal.lastModified()));
    System.out.printf("%30s = %s\n", "s1_normal.toURI()", s1_normal.toURI());
 
 
    // 列出“dir”目录下的“文件”和“文件夹”。
    // 注意：dir.listFiles()只会遍历目录dir，而不会遍历dir的子目录！
    System.out.println("---- list files and folders ----");
    File[] fs = dir.listFiles();
    for (File f:fs) {
      String fname = f.getName();
      String absStr = f.isAbsolute() ? "[Absolute]" : "";
      String hidStr = f.isHidden() ? "[Hidden]" : "";
      String dirStr = f.isDirectory() ? "[Directory]" : "";
      String fileStr = f.isFile() ? "[File]" : "";
 
      System.out.printf("%-30s %s%s%s%s\n", fname, fileStr, dirStr, absStr, hidStr);
    }
 
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  private static String getModifyTime(long millis) {
    // 获取Calendar对象
    Calendar cal = Calendar.getInstance();
    // 设置时间为 millis
    cal.setTimeInMillis(millis);
    // 获取格式化对象，它会按照"yyyy-MM-dd HH:mm:ss"格式化日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //System.out.printf("TIME %s\n", str);
    return sdf.format(cal.getTime());
  }
 
}

运行结果(在ubuntu 12.04系统下的运行结果，而不是windows！)：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
File.pathSeparator=":"
File.pathSeparatorChar=":"
File.separator="/"
File.separatorChar="/"
      s1_normal.exists() = true
      s1_normal.getName() = s1_normal.txt
     s1_normal.getParent() = dir/sub1
      s1_normal.getPath() = dir/sub1/s1_normal.txt
  s1_normal.getAbsolutePath() = /home/skywang/wind_talker/workout/java/skywang/io/io/src/file/dir/sub1/s1_normal.txt
 s1_normal.getCanonicalPath() = /home/skywang/wind_talker/workout/java/skywang/io/io/src/file/dir/sub1/s1_normal.txt
   s1_normal.lastModified() = 1381730064000 is "2013-10-14 13:54:24"
       s1_normal.toURI() = file:/home/skywang/wind_talker/workout/java/skywang/io/io/src/file/dir/sub1/s1_normal.txt
---- list files and folders ----
l1_uri.txt           [File]
sub1              [Directory]
l1_abs.txt           [File]
sub5              [Directory]
sub4              [Directory]
.l1_hide.txt          [File][Hidden]
sub3              [Directory]
sub2              [Directory]
l1_normal.txt          [File]

结果说明：运行程序，会在源文件所在的目录新建目录"dir"及其子目录和子文件。如下图：

详解Java中的File文件类以及FileDescriptor文件描述类

 

FileDescriptor

FileDescriptor 是“文件描述符”。
FileDescriptor 可以被用来表示开放文件、开放套接字等。
以FileDescriptor表示文件来说：当FileDescriptor表示某文件时，我们可以通俗的将FileDescriptor看成是该文件。但是，我们不能直接通过FileDescriptor对该文件进行操作；若需要通过FileDescriptor对该文件进行操作，则需要新创建FileDescriptor对应的FileOutputStream，再对文件进行操作。
in, out, err介绍
(1) in -- 标准输入(键盘)的描述符
(2) out -- 标准输出(屏幕)的描述符
(3) err -- 标准错误输出(屏幕)的描述符
它们3个的原理和用法都类似，下面我们通过out来进行深入研究。
1.1 out 的作用和原理
out是标准输出(屏幕)的描述符。但是它有什么作用呢？
我们可以通俗理解，out就代表了标准输出(屏幕)。若我们要输出信息到屏幕上，即可通过out来进行操作；但是，out又没有提供输出信息到屏幕的接口(因为out本质是FileDescriptor对象，而FileDescriptor没有输出接口)。怎么办呢？
很简单，我们创建out对应的“输出流对象”，然后通过“输出流”的write()等输出接口就可以将信息输出到屏幕上。如下代码：

?
1
2
3
4
5
6
try {
  FileOutputStream out = new FileOutputStream(FileDescriptor.out);
  out.write('A');
  out.close();
} catch (IOException e) {
}

执行上面的程序，会在屏幕上输出字母'A'。
为了方便我们操作，java早已为我们封装好了“能方便的在屏幕上输出信息的接口”：通过System.out，我们能方便的输出信息到屏幕上。
因此，我们可以等价的将上面的程序转换为如下代码：

?
1
System.out.print('A');

下面讲讲上面两段代码的原理
查看看out的定义。它的定义在FileDescriptor.java中，相关源码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
public final class FileDescriptor {
 
  private int fd;
 
  public static final FileDescriptor out = new FileDescriptor(1);
 
  private FileDescriptor(int fd) {
    this.fd = fd;
    useCount = new AtomicInteger();
  }
 
  ...
}

从中，可以看出
(1) out就是一个FileDescriptor对象。它是通过构造函数FileDescriptor(int fd)创建的。
(2) FileDescriptor(int fd)的操作：就是给fd对象(int类型)赋值，并新建一个使用计数变量useCount。
fd对象是非常重要的一个变量，“fd=1”就代表了“标准输出”，“fd=0”就代表了“标准输入”，“fd=2”就代表了“标准错误输出”。

?
1
FileOutputStream out = new FileOutputStream(FileDescriptor.out);

 就是利用构造函数FileOutputStream(FileDescriptor fdObj)来创建“Filed.out对应的FileOutputStream对象”。
关于System.out是如何定义的。可以参考"深入了解System.out.println("hello world") "
通过上面的学习，我们知道，我们可以自定义标准的文件描述符[即，in(标准输入),out(标准输出),err(标准错误输出)]的流，从而完成输入/输出功能；但是，java已经为我们封装好了相应的接口，即我们可以更方便的System.in, System.out, System.err去使用它们。
另外，我们也可以自定义“文件”、“Socket”等的文件描述符，进而对它们进行操作。参考下面示例代码中的testWrite(), testRead()等接口。
2. 示例代码
源码如下(FileDescriptorTest.java)：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
import java.io.PrintStream;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class FileDescriptorTest {
 
  private static final String FileName = "file.txt";
  private static final String OutText = "Hi FileDescriptor";
  public static void main(String[] args) {
    testWrite();
    testRead();
 
    testStandFD() ;
    //System.out.println(OutText);
  }
 
  /**
   * FileDescriptor.out 的测试程序
   *
   * 该程序的效果 等价于 System.out.println(OutText);
   */
  private static void testStandFD() {
    // 创建FileDescriptor.out 对应的PrintStream
    PrintStream out = new PrintStream(
        new FileOutputStream(FileDescriptor.out));
    // 在屏幕上输出“Hi FileDescriptor”
    out.println(OutText);
    out.close();
  }
 
  /**
   * FileDescriptor写入示例程序
   *
   * (1) 为了说明，"通过文件名创建FileOutputStream"与“通过文件描述符创建FileOutputStream”对象是等效的
   * (2) 该程序会在“该源文件”所在目录新建文件"file.txt"，并且文件内容是"Aa"。
   */
  private static void testWrite() {
    try {
      // 新建文件“file.txt”对应的FileOutputStream对象
      FileOutputStream out1 = new FileOutputStream(FileName);
      // 获取文件“file.txt”对应的“文件描述符”
      FileDescriptor fdout = out1.getFD();
      // 根据“文件描述符”创建“FileOutputStream”对象
      FileOutputStream out2 = new FileOutputStream(fdout);
 
      out1.write('A');  // 通过out1向“file.txt”中写入'A'
      out2.write('a');  // 通过out2向“file.txt”中写入'A'
 
      if (fdout!=null)
        System.out.printf("fdout(%s) is %s\n",fdout, fdout.valid());
 
      out1.close();
      out2.close();
 
    } catch(IOException e) {
      e.printStackTrace();
    }
  }
 
  /**
   * FileDescriptor读取示例程序
   *
   * 为了说明，"通过文件名创建FileInputStream"与“通过文件描述符创建FileInputStream”对象是等效的
   */
  private static void testRead() {
    try {
      // 新建文件“file.txt”对应的FileInputStream对象
      FileInputStream in1 = new FileInputStream(FileName);
      // 获取文件“file.txt”对应的“文件描述符”
      FileDescriptor fdin = in1.getFD();
      // 根据“文件描述符”创建“FileInputStream”对象
      FileInputStream in2 = new FileInputStream(fdin);
 
      System.out.println("in1.read():"+(char)in1.read());
      System.out.println("in2.read():"+(char)in2.read());
 
      if (fdin!=null)
        System.out.printf("fdin(%s) is %s\n", fdin, fdin.valid());
 
      in1.close();
      in2.close();
    } catch(IOException e) {
      e.printStackTrace();
    }
  }
}

运行结果：

?
1
2
3
4
5
fdout(java.io.FileDescriptor@2b820dda) is true
in1.read():A
in2.read():a
fdin(java.io.FileDescriptor@675b7986) is true
Hi FileDescriptor

 

  • Java
  • file
  • FileDescriptor

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 2000 　 1433 　 子线程 　 对象池模式 　 选择排序法 　 随机抽取 　 内存卡 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 短信猫 　 作业调度 　 短进程 　 空心菱形 　 htmlparser 　 支票 　 金额大写转换 　 微信企业号 　 终止循环体 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　
    © 2019-2020 服务器之家 版权所有 www.zzvips.com 关于我们联系我们版权申明网站地图