file_fileinputstream - CSDN
file 订阅
File,英文单词,名词、及物动词、不及物动词,作名词时意为“文件;档案;文件夹;锉刀,人名;(匈、塞)菲莱”,作及物动词时意为“提出;锉;琢磨;把…归档”,作不及物动词时意为“列队行进;用锉刀锉”。 展开全文
File,英文单词,名词、及物动词、不及物动词,作名词时意为“文件;档案;文件夹;锉刀,人名;(匈、塞)菲莱”,作及物动词时意为“提出;锉;琢磨;把…归档”,作不及物动词时意为“列队行进;用锉刀锉”。
信息
外文名
File
英式音标
[faɪl]
词    性
名词、及物动词、不及物动词
美式音标
[faɪl]
File短语搭配
file system [计] 文件系统 ; 档案系统 ; 文件体系 ; 文件编制file server 文件服务器 ; 档案伺服器 ; 档案服务器 ; 文件服务程序log file 日志文件 ; 访客流量统计文件 ; 记录档 ; 记录文件register file 寄存器堆 ; [计] 寄存器文件 ; 寄存器组File Explorer 文件资源管理器 ; 文件管理器 ; 文件浏览器 ; 资源管理器Source file [计] 源文件 ; 来源文件 ; 来源档案temporary file [计] 临时文件 ; 暂存文件 ; 暂时档案nail file 指甲锉 ; 指甲锉刀inverted file 倒排文件 ; [计] 倒置文件 ; 倒向文件 ; 倒排文档 [1] 
收起全文
精华内容
参与话题
  • File文件的一些基本方法和操作

    万次阅读 2017-08-15 20:09:21
    1.File对象对应你磁盘上的一个文件或者文件夹(路径),一个file对象代表了一个文件或者文件夹的引用,并不是直接物理上的。2.File.separator: 连接符 public static final String separator与系统相关的默认名称 - ...

    1.File对象对应你磁盘上的一个文件或者文件夹(路径),一个file对象代表了一个文件或者文件夹的引用,并不是直接物理上的。

    2.File.separator: 连接符
    public static final String separator与系统相关的默认名称 - 分隔符字符,以方便的方式表示为字符串。 该字符串包含一个字符,即separatorChar 。 (public static final char separatorChar与系统相关的默认名称分隔符。 该字段被初始化为包含系统属性值file.separator的第一个file.separator 。 在UNIX系统上,该字段的值为’/’ ; 在Microsoft Windows系统上是’\’ 。 )

    3.创建File实例对象的几种方式
    第一种:

        File file = new File("D:\\abc.txt");
        System.out.println(file);

    第二种:

    // parent  前面的路径   chid  在parent 后面追加的目录
            File file2 = new File("D:\\c", "abc.txt");
            System.out.println(file2);

    第三种:

           File  parent = new File("D:\\d");
            File file3 = new  File(parent, "qwe.doc");
            System.out.println(file3);

    4.创建文件

    //返回的是否创建成功
        try {
                boolean flag = file.createNewFile();
                System.out.println(flag);
            } catch (IOException e) {
                e.printStackTrace();
            }

    5.判断文件是否可读写canRead() canWrite()

            System.out.println(file.canRead());
            // 判断文件是否可写
            System.out.println(file.canWrite());

    6 . 判断文件是否存在exists(), 如果不存在则 创建, 存在则不创建了

    if(!file2.exists()){// 判断文件是否存在
                try {
                    file2.createNewFile();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else{
                System.out.println("已经存在了 ");
            }

    7 .创建文件夹 单层mkdir()

            String string = "D:\\d";
            File file = new File(string);
            boolean flag = file.mkdir();// 创建文件夹  单层
            System.out.println(flag);

    8 .利用mkdirs 可以同时创建多层目录

    File file2 = new File("D:\\d\\a\\c\\w");
            file2.mkdirs();// 利用mkdirs 可以同时创建多层目录

    9 . 如何区分 文件或者是 文件夹

          if(file2.isDirectory()){// 判断是否是文件夹
                System.out.println("是文件夹");
            }
            if(file3.isFile()){
                System.out.println("是文件");
            }

    10 . 删除指定文件

            File file2 = new File("D:\\d\\a\\c\\w");    
            File file3 = new File(file2, "abc.txt");
            boolean flag2 = file3.delete();
            System.out.println(flag2);

    11 .length()判断文件的长度 而非文件夹的长度 ,返回long类型的

            long l = file3.length();
            System.out.println(l);

    12 .得到路径

    File file = new File("D:\\d\\a\\c\\w\\abc.txt");
            System.out.println(file.getPath());// 得到路径

    13 .System.out.println(file.getParent());// 得到 文件的父目录

    14 . System.out.println(file.getParentFile());// 得到 文件的父目录 返回的是File对象

    15 .// 重命名 被其他 占用的时候 就不能重命名成功

        File file3 = new File("D:\\d\\a\\c\\w\\hehe.txt");
            boolean flag = file.renameTo(file3);
            System.out.println(flag);

    16.将文件过滤掉,文件夹保留

    package com.qf.demo2;
    
    import java.io.File;
    import java.io.FilenameFilter;
    
    /**
     * list()  返回 指定目录  下的   所有 的  目录和文件的名字   String[]
     * list(FilenameFilter filter)  得到的所有的名字 进行对应的过滤
     * 
     * 
     * 
     * listFiles()   返回 指定目录  下的   所有 的  目录和文件的   file 对象表现形式  File[]
     * listFiles(FilenameFilter filter)  得到的所有的名字 进行对应的过滤
     * 
     */
    public class Test4 {
    
        public static void main(String[] args) {
    
            //File file = new  File("D\\java上课内容\\2015新版PPT":);
            File file = new File("D:\\java上课内容");
            String[] strings = file.list();
            /*for (String string : strings) {
                System.out.println(string);
            }
            File[] files = file.listFiles();
            for (File file2 : files) {
                System.out.println(file2);
            }*/
    
    
            String[] strings2 = file.list(new MyFilter());
            for (String string : strings2) {
                System.out.println(string);
            }
    
            File[] file2 = file.listFiles(new MyFilter());
            for (File file3 : file2) {
                System.out.println(file3);
            }
    
        }
    }
    
    class MyFilter implements FilenameFilter{
    
        // dir 指定的目录        name 是 dir 指定目录下的文件或者是文件夹的名字
        public boolean accept(File dir, String name) {      
    //      if(name.endsWith(".txt")){
    //          return false;
    //      }
            // 假如是  文件   就 过滤掉, 如果是文件夹 , 就保留
            //  D:\\java上课内容      \\   java新版ppt
            File file = new File(dir,name);
            if(file.isFile()){
                return false;
            }
    
    
            return true;// 返回ture 证明 保留下来的
                        // 返回 false 要被过滤掉的
        }
    
    }
    

    17 .得到指定文件夹下的所有的文件

    package com.qf.demo2;
    
    import java.io.File;
    
    /**
     * 递归
     * 自己调用自己
     * 以此类推
     * 同性质的问题  范围缩小, 直到 结果 可以直接的出来
    
     需求: 得到指定文件夹下的所有的文件
    
    
    计算 指定文件夹  所有文件 和 文件夹的个数
    
     */
    public class Test5 {
    
        public static void main(String[] args) {
    
            findFile(new File("D:\\java上课内容"));
        }
    
        // 得到 指定文件夹下一层的所有的文件和文件
        // // 如果是文件  打印输出, 如果文件夹 
    
        public static void  findFile(File file){// 既可以代表文件也可以代表文件夹
            // 保证非空
            if(file != null){
                // 保证是文件夹
                if(!file.isFile()){
                    // 得到文件夹下的文件或者是 文件夹了
                    File[] files = file.listFiles();// 新版ppt  ppt  .pptx
                    for (File file2 : files) {// 把所有的文件和文件夹遍历一遍
                            findFile(file2);// 无论是文件还是文件夹 都可以调用  此方法
                    }
                }else{
                    System.out.println(file);
                }
            }else{
                System.out.println("闹着玩呢??????");
            }
        }
    }
    
    展开全文
  • File类简介及常用功能

    千次阅读 2018-01-04 10:52:45
    File类简介及常用功能 (1)IO流操作中大部分都是对文件的操作,所以Java就提供了File类供我们来操作文件 (2)构造方法 A:File file = new File("e:\\demo\\a.txt"); B:File file = new File("e:\\demo","a.txt")...

    File类简介及常用功能

    (1)IO流操作中大部分都是对文件的操作,所以Java就提供了File类供我们来操作文件
        (2)构造方法
            A:File file = new File("e:\\demo\\a.txt");
            B:File file = new File("e:\\demo","a.txt");
            C:File file = new File("e:\\demo");
              File file2 = new File(file,"a.txt");
        (3)File类的功能
            A:创建功能
                public boolean createNewFile();
                public boolean mkdir();
                public boolean mkdirs();
            B:删除功能
                public boolean delete()
            C:重命名功能
                public boolean renameTo(File file)
            D:判断功能
                public boolean isDirectory();
                public boolean isFile();
                public boolean exists();
                public boolean canRead()
                public boolean canWrite()
                public boolean isHidden()
            E:获取功能
                public String getName();
                public String getAbsolutePath();//获取绝对路径,如果file对象中本身就是绝对路径,就和getPath()相同
                public String getPath();
                public long length();
                public long lastModified();
            F:高级获取功能
                public String[] list()
                public File[] listFiles() 
            G:过滤器功能
                public String[] list(FileNameFilter filter)
                public File[] listFiles(FileNameFilter filter)
    展开全文
  • C语言详解 FILE文件操作

    万次阅读 多人点赞 2019-12-23 13:17:11
    1. 需要了解的概念 需要理解的知识点包括:数据流、缓冲区、文件类型、文件存取方式 1.1 数据流: 指程序与数据的交互是以流的形式进行的。进行C语言文件的存取时,都会先进行“打开文件”操作,这个操作就是在...

    1. 需要了解的概念

    需要理解的知识点包括:数据流、缓冲区、文件类型、文件存取方式
     

    1.1 数据流:

    指程序与数据的交互是以流的形式进行的。进行C语言文件的存取时,都会先进行“打开文件”操作,这个操作就是在打开数据流,而“关闭文件”操作就是关闭数据流。

    1.2 缓冲区(Buffer):

    指在程序执行时,所提供的额外内存,可用来暂时存放做准备执行的数据。它的设置是为了提高存取效率,因为内存的存取速度比磁盘驱动器快得多。

     C语言中带缓冲区的文件处理:

    C语言的文件处理功能依据系统是否设置“缓冲区”分为两种:一种是设置缓冲区,另一种是不设置缓冲区。由于不设置缓冲区的文件处理方式,必须使用较低级的I/O函数(包含在头文件io.h和fcntl.h中)来直接对磁盘存取,这种方式的存取速度慢,并且由于不是C的标准函数,跨平台操作时容易出问题。下面只介绍第一种处理方式,即设置缓冲区的文件处理方式:

    当使用标准I/O函数(包含在头文件stdio.h中)时,系统会自动设置缓冲区,并通过数据流来读写文件。当进行文件读取时,不会直接对磁盘进行读取,而是先打开数据流,将磁盘上的文件信息拷贝到缓冲区内,然后程序再从缓冲区中读取所需数据,如下图所示:

    事实上,当写入文件时,并不会马上写入磁盘中,而是先写入缓冲区,只有在缓冲区已满或“关闭文件”时,才会将数据写入磁盘,如下图所示。


    1.3 文件类型:

    分为文本文件和二进制文件两种。

    文本文件是以字符编码的方式进行保存的。二进制文件将内存中数据原封不至文件中,适用于非字符为主的数据。如果以记事本打开,只会看到一堆乱码。

    其实,除了文本文件外,所有的数据都可以算是二进制文件。二进制文件的优点在于存取速度快,占用空间小,以及可随机存取数据。
     

    1.4 文件存取方式:

    包括顺序存取方式和随机存取方式两种。

    顺序读取也就是从上往下,一笔一笔读取文件的内容。保存数据时,将数据附加在文件的末尾。这种存取方式常用于文本文件,而被存取的文件则称为顺序文件。

    随机存取方式多半以二进制文件为主。它会以一个完整的单位来进行数据的读取和写入,通常以结构为单位。


    2. 文本文件操作

    C语言中主要通过标准I/O函数来对文本文件进行处理。相关的操作包括打开、读写、关闭与设置缓冲区。
    相关的存取函数有:fopen(), fclose(), fgetc(), fputc(), fgets(), fputs(), fprintf(), fscanf()等。
     

    2.1 打开文件

    函数原型为:_CRTIMP FILE * __cdecl fopen(const char *, const char *);

    第一参数为文件名,第二个参数为打开模式。

    打开成功,fopen返回一个结构指针地址,否则返回一个NULL。如果没有指定文件路径,则默认为当前工作目录。如:

    FILE *fp;
    fp = fopen("c:\\temp\\test.txt", "r") //由于反斜杠\是控制字符,所以必须再加一个反斜杠

     

    使用fopen()函数打开的文件会先将文件复制到缓冲区。注意:所下达的读取或写入动作,都是针对缓冲区进行存取而不是磁盘,只有当使用fclose()函数关闭文件时,缓冲区中的数据才会写入磁盘。
     

      谈文件打开模式

    打开文本文件:

    "r":只能从文件中读数据,该文件必须先存在,否则打开失败
    "w":只能向文件写数据,若指定的文件不存在则创建它,如果存在则先删除它再重建一个新文件
    "a":向文件增加新数据(不删除原有数据),若文件不存在则打开失败,打开时位置指针移到文件末尾
    "r+":可读/写数据,该文件必须先存在,否则打开失败
    "w+":可读/写数据,用该模式打开新建一个文件,先向该文件写数据,然后可读取该文件中的数据
    "a+":可读/写数据,原来的文件不被删去,位置指针移到文件末尾

    打开二进制文件的模式与打开文本文件的含义是一样的,不同的是模式名称里面多一个字母'b’,以表示以二进制形式打开文件。
     

    2.2 关闭文件

    函数原型为:_CRTIMP int __cdecl fclose(FILE *);

    关闭成功返回值0,否则返回非零值。

    注:在执行完文件的操作后,要进行“关闭文件”操作。虽然程序在结束前会自动关闭所有的打开文件,但文件打开过多会导致系统运行缓慢,这时就要自行手动关闭不再使用的文件,来提高系统整体的执行效率。

     

    例1. 打开文件并进行判断和关闭文件

     

    FILE *fp;
    fp = fopen("c:\\temp\\test.txt", "r");

    if(fp == NULL)
        printf("fail to open the file! \n");
    else
    {
        printf("The file is open! \n");
        fclose(fp);
    }

     

     

    2.3 字符存取函数

    函数原型为:

    _CRTIMP int __cdecl fputc(int, FILE *);
    _CRTIMP int __cdecl fgetc(FILE *);

    字符读取函数fgetc()可从文件数据流中一次读取一个字符,然后读取光标移动到下一个字符,并逐步将文件的内容读出。

    如果字符读取成功,则返回所读取的字符,否则返回EOF(end of file)。EOF是表示数据结尾的常量,真值为-1。另外,要判断文件是否读取完毕,可利用feof()进行检查。未完返回0,已完返回非零值。

    feof()函数原型为:_CRTIMP int __cdecl feof(FILE *);

    例2. fgetc()函数的使用

    版本1:利用feof()函数检查文件是否读取完毕

     

    #include <stdio.h>

    main()
    {
        FILE *fp;
        fp = fopen("c:\\temp\\test.txt", "r");
        if(fp != NULL)
        {
            while(!feof(fp))
                printf("%c", fgetc(fp));
        }
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     


    版本2:利用文件结束标志EOF(即-1)

     

    #include <stdio.h>

    main()
    {
        char ch;
        FILE *fp;
        fp = fopen("c:\\temp\\test.txt", "r");
        if(fp != NULL)
        {
            ch = fgetc(fp);
            while(ch != EOF)
            {
                putchar(ch);
                ch = fgetc(fp);
            }

        }
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     


    版本3 - 重构版本2

     

    #include <stdio.h>

    main()
    {
        char ch;
        FILE *fp;
        if((fp = fopen("test.txt", "r")) != NULL)
            while((ch = fgetc(fp)) != EOF)
                putchar(ch);
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     


    版本4 - 重构版本3 (不正确的重构)

     

    #include <stdio.h>

    main()
    {
        FILE *fp;
        if((fp = fopen("test.txt", "r")) != NULL)
            while(fgetc(fp) != EOF)
                putchar(fgetc(fp));
        else
            printf("fail to open! \n");
        fclose(fp);

        return 0;
    }

     



    若要将字符逐一写入文件,用fputc()函数。示例为:

    例3. fputc()函数的使用

     

    #include <stdio.h>
    #include <conio.h>

    main()
    {
        char filename[20], ch;
        FILE *fp;
        printf("Enter a filename: ");
        scanf("%s", filename);
        printf("Enter some characters to output to file: ");
        if((fp = fopen(filename, "w")) == NULL)
            printf("fail to open! \n");
        else
        {
            while((ch = getche()) != '\015')
                fputc(ch, fp);
        }
        fclose(fp);

        return 0;
    }

     


     

    2.4 字符串存取函数

    函数原型为:

    _CRTIMP int __cdecl fputs(const char *, FILE *);
    _CRTIMP char * __cdecl fgets(char *, int, FILE *);

    fgets函数的作用是从指定文件读入一个字符串,如:fgets(str, n, fp);

    参数n为要求得到的字符个数,但只从fp指向的文件输入n-1个字符,然后在最后加一个'\0'字符,因此得到的字符串共有n个字符,把它们放在字符数组str中。如果在读完n-1个字符之前遇到换行符或EOF,读入结束。

    fputs函数的作用是向指定文件输出一个字符串,如:fputs("Hey", fp);

    把字符串"Hey"输出到fp指向的文件。fputs函数的第一个参数可以是字符串常量、字符数组名或字符型指针。若输出成功,则返回0,否则返回EOF。

    实例略

     

    2.5 格式化存取函数

    函数原型为:

    _CRTIMP int __cdecl fprintf(FILE *, const char *, ...);
    _CRTIMP int __cdecl fscanf(FILE *, const char *, ...);

    它们与printf和scanf函数相仿,都是格式化读写函数。不同的是:fprintf和fscanf函数的读写对象不是终端(标准输入输出),而是磁盘文件。printf函数是将内容输出到终端(屏幕),因此,fprintf就是将内容输出到磁盘文件了。

    实例4. fprintf和fscanf函数的使用

     

    #include <stdio.h>

    void main()
    {
        FILE *fp;

        int num = 10;
        char name[10] = "Leeming";
        char gender = 'M';

        if((fp = fopen("info.txt", "w+")) == NULL)
            printf("can't open the file! \n");
        else
            fprintf(fp, "%d, %s, %c", num, name, gender); //将数据格式化输出到文件info.txt中

        fscanf(fp, "%d, %s, %c", &num, name, &gender); //从文件info.txt中格式化读取数据
        printf("%d, %s, %c \n", num, name, gender); //格式化输出到屏幕

        fclose(fp);
    }

     


     

    2.6 指针重返函数

    函数原型为:

    _CRTIMP void __cdecl rewind(FILE *);;

    rewind函数的作用是使位置指针重返回文件的开头,属于文件的定位。

     

    3. 二进制文件操作

    3.1 数据块存取函数

    函数原型:

    _CRTIMP size_t __cdecl fread(void *, size_t, size_t, FILE *);
    _CRTIMP size_t __cdecl fwrite(const void *, size_t, size_t, FILE *);

    当要求一次存取一组数据(如,一个数组、一个结构体变量的值),fread和fwrite函数可以解决该类问题。它们的调用形式一般为:

    fread(buffer, size, count, fp);
    fwrite(buffer, size, count, fp);

    buffer:对于fread来说,指的是读入数据的存放地址;对于fwrite来说,是要输出数据的地址。
    size:读写数据时,每笔数据的大小
    count:读写数据的笔数
    fp:文件指针
     

    实例5. fread和fwrite函数的使用

     

    #include <stdio.h>
    #define SIZE 3

    typedef enum { MM, GG } Gender;

    typedef struct
    {
        char name[10];
        int  age;
        Gender gender;
    } Person;

    void write2file(Person emp[SIZE])
    {
        FILE *fp;
        if((fp = fopen("emp.txt", "wb")) == NULL)
        {
            printf("cannot open file! \n");
            return;
        }

        for(int i=0; i<SIZE; i++)
            if(fwrite(&emp[i], sizeof(Person), 1, fp) != 1)
                printf("file write error! \n");
        fclose(fp);
    }

    void read_from_file(FILE *fp)
    {
        Person emp_out[SIZE];

        if((fp = fopen("emp.txt", "rb")) == NULL)
        {
            printf("cannot open file! \n");
            return;
        }

        printf("\n%d employee's information read: \n", SIZE);

        for(int i=0; i<SIZE; i++)
        {
            if(fread(&emp_out[i], sizeof(Person), 1, fp) != 1)
                if(feof(fp))
                {
                    fclose(fp);
                    return;
                }
                printf("%-5s %4d %5d \n", emp_out[i].name, emp_out[i].age, emp_out[i].gender);
        }
        fclose(fp);
    }

    void main()
    {
        FILE *fp = NULL;
        Person employee[SIZE];

        printf("Enter %d employee's information: \n", SIZE);
        for(int i=0; i<SIZE; i++)
            scanf("%s %d %d", employee[i].name, &employee[i].age, &employee[i].gender);

        write2file(employee);

        read_from_file(fp);
    }

     


     

    3.2 随机存取函数fseek()

    函数原型:

    _CRTIMP int __cdecl fseek(FILE *, long, int);

    对流式文件可以进行顺序读写,也可以进行随机读写。关键在于控制文件的位置指针,如果位置指针是按字节位置顺序移动的,就是顺序读写。如果能将位置指针按需要移动到任意位置,就可以实现随机读写。所谓随机读写,是指读完上一个字符(字节)后,并不一定要读写其后续的字符(字节),而可以读写文件中任意位置上所需要的字符(字节)。该函数的调用形式为:

    fseek(fp, offset, start);

    start:起始点。用0、1、2代替。0代表文件开始,名字为SEEK_SET,1代表当前位置,名字为SEEK_CUR,2代表文件末尾,名字为SEEK_END。

    fseek()函数一般用于二进制文件,因为文本文件要发生字符转换,计算位置时往往会发生混乱。

    调用实例如:

    fseek(fp, i*sizeof(Person), 0);

     

    https://blog.csdn.net/yong_sun/article/details/8921061

    展开全文
  • JAVA基础知识之File

    万次阅读 多人点赞 2018-07-13 10:46:30
    一、File类定义 1. File类主要是JAVA为文件这块的操作(如删除、新增等)而设计的相关类 2. File类的包名是java.io,其实现了Serializable, Comparable两大接口以便于其对象可序列化和比较public class File ...

    一、File类定义

                1. File类主要是JAVA为文件这块的操作(如删除、新增等)而设计的相关类

                2. File类的包名是java.io,其实现了Serializable, Comparable两大接口以便于其对象可序列化和比较

    public class File implements Serializable,Comparable<File>
    {
    }

    二、File类实例域

    1) path :封装的String类型变量,代表了文件的路径

     private String path;
     public String getPath() 
    {
            return path;
    }
    

    2) separatorChar:静态常量,代表了运行该程序的系统的路径分隔符,windows系统为"\" ,linux系统为“/”

     public static void main(String[] args)
    {
        
        System.out.println(File.separator); //在windows系统下运行结果为\
        
    }

    3)  separator :静态常量,是由separatorChar扩展而来的字符串型常量,运行结果和separatorChar一样

    public static final String separator = "" + separatorChar;

    4)pathSeparatorChar :静态常量,代表用于分割多个路径的系统分隔符。 在UNIX系统上,此字符为':'而 Windows系统上它是';'

     public static void main(String[] args)
    {
        
        System.out.println(File.pathSeparator); //运行结果为;
    }

    5)pathSeparator: 静态常量,由pathSeparatorChar扩展而来的字符串,运行结果和pathSeparatorChar一样

     public static final String pathSeparator = "" + pathSeparatorChar;

    三、File类构造函数

    注意:构造函数只是创建一个File实例,并没有以文件做读取等操作,因此路径即使是错误的,也可以创建实例不报错

    1)通过给定的字符串路径(一般是文件的绝对路径)转为抽象路径名用来创建File实例,当传入null时会抛出NullPointerException空异常错误

        public File(String pathname) {}
    public class Test2
    {
    
     public static void main(String[] args)
    {
         File file=new File("xxx");
    
        System.out.println(file.getPath());  //路径结果就是xxx
    }
    }

    2)从父路径名字符串和子路径名字符串(一般是相对父类的相对路径)创建新的File实例

    public File(String parent, String child) {}

         2.1) 若子路径child为Null,会抛出NullPointerException空异常错误

         2.2) 当父路径为Null时,会以子路径child作为绝对路径创建实例,等同于调用第一个File(String child )效果一样

    public class Test2
    {
    
     public static void main(String[] args)
    {
         String parent=null;
         
         File file=new File(parent,"xxx");
    
        System.out.println(file.getPath());  //路径结果就是xxx
    }
    }

        2.3) 当父路径不为空时,会以父路径作为目录,子路径作为父路径下的目录或者文件名,最后得到的实例对象的路径就是父路径和子路径的组合

    public class Test2
    {
    
        public static void main(String[] args)
        {
            String parent = "E:/test";
            
            File parentFile= new File(parent);
    
            String child = "E:/test/1.txt";
    
            File file = new File(parentFile, child);
    
            System.out.println(file.getPath()); // 路径结果就是E:\test\E:\test\1.txt
        }
    }

    3)通过父路径File实例对象和子路径字符串创建新的File实例,等同于上面的方法中把父路径字符串创建File实例然后传入一样

    public class Test2
    {
    
        public static void main(String[] args)
        {
            String parent = "E:/test";
            
            File parentFile= new File(parent);
    
            String child = "E:/test/1.txt";
    
            File file = new File(parentFile, child);
    
            System.out.println(file.getPath()); // 路径结果就是E:\test\E:\test\1.txt
        }
    }

    4)通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例,这个方法暂时没有看懂,需要查阅资料加深理解

    public File(URI uri) {}

    四、File类中的各种常用方法

           下面是我E盘下test文件夹的文件情况,以此作为案例


    1)获取实例对象代表的文件名字(包含文件后缀)

    public String getName()}
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.getName()); // 结果是1.txt
    
            System.out.println(file2.getName()); // 结果是异常1.jpg
    
            System.out.println(file3.getName()); // 结果是xxx
    
        }
    }

    2)获取实例对象代表的文件上级目录

    public String getParent()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.getParent()); // 结果是E:\test
    
            System.out.println(file2.getParent()); // 结果是E:\test
    
            System.out.println(file3.getParent()); // 结果是null
    
        }
    }
    

    3)获取实例对象的父项的实例对象,如果此路径名未指定父目录,则返回null;也就是获取对象的上级目录然后再实例化一个对象

    public File getParentFile()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.getParentFile()); // 结果是E:\test
    
            System.out.println(file2.getParentFile()); // 结果是E:\test
    
            System.out.println(file3.getParentFile()); // 结果是null
    
        }
    }

    4)获取实例对象代表的文件的实际路径

    public String getPath()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.getPath()); // 结果是E:\test\1.txt
    
            System.out.println(file2.getPath()); // 结果是E:\test\异常1.jpg
    
            System.out.println(file3.getPath()); // 结果是xxx
    
        }
    }
    

    5)检测该实例对象代表的文件的路径是否是绝对路径(windows系统中路径是以驱动盘开始的就是绝对路径)

    public boolean isAbsolute()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.isAbsolute()); // 结果是true
    
            System.out.println(file2.isAbsolute()); // 结果是true
    
            System.out.println(file3.isAbsolute()); // 结果是false
    
        }
    }
    

    6)获取实例对象代表的文件的绝对路径

    public String getAbsolutePath()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.getAbsolutePath()); // 结果是E:\test\1.txt
    
            System.out.println(file2.getAbsolutePath()); // 结果是E:\test\异常1.jpg
    
            System.out.println(file3.getAbsolutePath()); // 结果是D:\workspace\lettcode\xxx(编译器的工作空间作为解析目录了)
    
        }
    }

    7)实例对象代表的文件是否存在

    public boolean exists()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.exists()); // 结果是true
    
            System.out.println(file2.exists()); // 结果是true
    
            System.out.println(file3.exists()); // 结果是false
    
        }
    }

    8)检测实例对象代表的是否是文件

    public boolean isFile()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.isFile()); // 结果是true
    
            System.out.println(file2.isFile()); // 结果是true
    
            System.out.println(file3.isFile()); // 结果是false
    
        }
    }

    9)检测实例对象代表的是否是目录

    public boolean isDirectory()
    public class Test2
    {
    
        public static void main(String[] args) throws URISyntaxException
        {
    
            File file = new File("E:/test/1.txt");
    
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.isDirectory()); // 结果是false
    
            System.out.println(file2.isDirectory()); // 结果是false
    
            System.out.println(file3.isDirectory()); // 结果是false
    
        }
    }

    10)创建新文件--当且仅当实例对象代表的文件不存在时才可以创建新文件

    public boolean createNewFile()  throws IOException
    public class Test2
    {
    
        public static void main(String[] args) throws  IOException
        {
    
            File file = new File("E:/test/1.txt");
            
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.createNewFile()); // 结果是false,已经存在无法创建
    
            System.out.println(file2.createNewFile()); // 结果是false,已经存在无法创建
    
            System.out.println(file3.createNewFile()); // 结果是true,不存在可以创建
    
        }
    }
    

    创建的XXX文件的目录地址是以编译器的工作空间为上级目录加上创建实例对象的时候的路径名形成最后的路径



     11)删除实例对象代表的文件或目录,当代表目录时,必须目录下为空才可以删除

    public boolean delete()
    public class Test2
    {
    
        public static void main(String[] args) throws  IOException
        {
    
            File file = new File("E:/test/");
            
            File file2 = new File("E:/test/异常1.jpg");
    
            File file3 = new File("xxx"); // 错误路径
    
            System.out.println(file.delete()); // 结果是false,目录无法删除
    
            System.out.println(file2.delete()); // 结果是true,文件可以删除
    
            System.out.println(file3.delete()); // 结果是true,文件可以删除
    
        }
    }
    

    执行方法后的test文件如下:



    12)根据实例对象的路径名创建目录(若目录已存在,则false;若路径是文件,则fasle;若路径的上级目录不存在则false)

    public boolean mkdir()
    public class Test2
    {
    
        public static void main(String[] args) throws IOException
        {
    
            File file = new File("E:/test1/");
    
            File file2 = new File("E:/test2/异常1.jpg");
    
            File file3 = new File("E:/ceshi");
    
            File file4 = new File("E:/ceshi2/2018");
    
            System.out.println(file.mkdir()); // false 因为test1目录已存在
    
            System.out.println(file2.mkdir()); // false,因为上级目录test2不存在
    
            System.out.println(file3.mkdir()); // true,因为ceshi目录不存在且是上级目录是E盘存在的
    
            System.out.println(file4.mkdir()); // false,因为ceshi2目录不存在,所以不成功
    
        }
    }


    13)根据实例对象的路径创建目录,包括创建那些必须的且不存在的父级目录

    public boolean mkdirs()
    public class Test2
    {
    
        public static void main(String[] args) throws IOException
        {
    
            File file = new File("E:/test1/");
    
            File file2 = new File("E:/test2/异常1.jpg");
    
            File file3 = new File("E:/ceshi");
    
            File file4 = new File("E:/ceshi2/zhagnsan");
    
            System.out.println(file.mkdirs()); // false 因为test1目录已存在
    
            System.out.println(file2.mkdirs()); // true,因为目录不存在所以可以创建,但注意生成的异常1.jpg是文件夹不是图片
    
            System.out.println(file3.mkdirs()); // true,因为目录不存在所以可以创建
    
            System.out.println(file4.mkdirs()); // true,因为目录不存在所以可以创建
    
        }
    }
    

    14) 获取实例对象代表的文件下的各级文件名和目录名,返回一个字符串数组      

    public String[] list()

            1.  当实例对象代表的是文件不是目录时,返回NUll对象

            2.  获取的是该目录下的文件名和目录名,并不包含该目录名称和其上级目录名称

            3.  字符串数组中都是文件名或目录名并不是路径名

            4.  字符串中的元素并不是按照实际系统中目录下的顺序排列的

    例如E盘test文件夹里面是这样的



    调用list方法

    public class Test2
    {
    
        public static void main(String[] args) throws IOException
        {
    
            File file2 = new File("E:/test");
    
            String[] list = file2.list();
    
            for (int i = 0; i < list.length; i++)
            {
                System.out.println(list[i]); // 结果为1.txt、xxx、工资表.xls、异常1.jpg、第一个目录、第三个目录
            }
    
        }
    }

    15)获取实例对象代表的文件下的各级文件名和目录名并指定过滤器进行过滤,返回一个字符串数组     

    public String[] list(FilenameFilter filter)

        1. 过滤器是FilenameFilter类对象,当传入null时,效果和list()方法一样

        2. 过滤器是指过滤掉不符合名称的名字

        3. FilenameFilter 是一个接口,因此需要自己新建一个类来实现该接口作为参数传入进去

        4.仔细研究方法的源码可以发现,所谓过滤就是要重写FilenameFilter的accept方法并在方法中过滤

    public String[] list(FilenameFilter filter) {
            String names[] = list();
            if ((names == null) || (filter == null)) {
                return names;
            }
            List<String> v = new ArrayList<>();
            for (int i = 0 ; i < names.length ; i++) {
                if (filter.accept(this, names[i])) {  //必须重写accept方法,并在方法内对传入的name进行判定是否合乎过滤条件
                    v.add(names[i]);
                }
            }
            return v.toArray(new String[v.size()]);
        }
    

          5. 例如我们只要后缀名是txt的文件名称,那么可以按照以下逻辑来处理

    创建FilenameFilter的实现类TxtFilter并重写accept方法,在方法中进行判定

    public class TxtFilter implements FilenameFilter
    {
    
        @Override
        public boolean accept(File dir, String name)
        {
            if(name.endsWith(".txt"))
            {
                return true;
            }
            return false;
        }
    
    }

    但是仔细思考,如果我还需要过滤.java结束的呢?难道又去重新创建实现类?因此可以用过滤条件作为构造参数传入构造方法中初始化其变量,这样就是可变的

    public class TxtFilter implements FilenameFilter
    {
    
        private String FilterName; // 作为过滤器名称变量
    
        public TxtFilter(String FilterName)
        {
    
            this.FilterName = FilterName; // 初始化构造过滤器名称,这样就不用每次都创建新类
    
        }
    
        public String getFilterName()
        {
    
            return FilterName; // 公有的域访问器方法,提供接口获取
        }
    
        @Override
        public boolean accept(File dir, String name)
        {
    
            String fileterNameString = this.getFilterName(); // this代表着调用accept方法的变量
    
            if (name.endsWith(fileterNameString))
            {
                return true;
            }
            return false;
        }
    
    }

    我们测试下结果

    public class Test2
    {
    
        public static void main(String[] args) throws IOException
        {
    
            File file2 = new File("E:/test");
            
            TxtFilter filter=new TxtFilter(".txt"); //过滤器,只需要.txt结尾的
            
            String[] list = file2.list(filter);
    
            for (int i = 0; i < list.length; i++)
            {
                System.out.println(list[i]); // 结果为1.txt
            }
    
        }
    }



      


    展开全文
  • 简述File类的作用及方法

    千次阅读 2019-04-25 21:33:34
    简述File类的作用 一个File对象而可以代表一个文件或目录, File可以实现获取文件和目录属性等功能, 可以实现对文件和目录的创建,删除等功能 File类操作目录与文件的常用方法有哪些 文件方法: 对象名....
  • 之前安装uwsgi的时候编译一步有出错,因为比较早,部分错误代码已经找不到了,网上找了部分错误信息, 现把解决方式共享出来。 环境:CentOS release 6.4 Python 2.7.3 报类似下面的错误代码,多半因为...
  • 关于python中的setup.py

    万次阅读 2014-11-14 10:41:32
    本文是转载的,源地址:http://lingxiankong.github.io/blog/2013/12/23/python-setup/ 感谢作者,解决了我一个大问题
  • 一、问题的出现 为了做个自动选课的小脚本,废了不少功夫。感觉比自己手动抢麻烦了许多。不过,谁让咱家就喜欢倒腾,所以,在选课期间,花了一天的时间把这个自动抢课脚本搞好了,当然还有许多需要继续完善的地方,...
  • File "/usr/bin/mycli", line 7, in module> from mycli.main import cli File "/usr/lib/python2.6/site-packages/mycli/main.py", line 305 return {x: get(x) fo
  • 【C语言】文件(FILE)

    千次阅读 多人点赞 2019-04-05 23:19:07
    文章目录一、文件1.1 文件类型指针1.2 文件的打开与关闭1.2.1 文件的打开1.2.2 文件的关闭1.3 文件的读写1.3.1 文本文件的读写1.3.1.1 写字符函数fputc和读字符函数fgetc1.3.1. 2 写字符串函数fputs和读字符串函数...
  • Java中的File文件类详解

    万次阅读 多人点赞 2016-08-02 22:02:45
    Java中的File文件类详解文件操作在Java的io操作中占有十分重要的地位,本文从以下几个方面来接受Java中对文件的操作。 1. Java中新建或者删除一个文件,文件夹以及createNewFile(),delete(),mkdir(),mkdirs()函数的...
  • 【C语言】C语言FILE详解

    万次阅读 2016-11-17 09:02:46
    1 C语言file类,在stdio.h 头文件中,FILE类是一个结构体:定义如下: struct _iobuf {  char *_ptr;  int _cnt;  char *_base;  int _flag;  int _file;  int _charbuf;  
  • FileUtils工具类常用方法

    万次阅读 2020-07-14 13:51:22
    文件操作工具类(FileUtils) 使用 apache 的commons-io包下的FileUtils,import org.apache.commons.io.FileUtils; 下载地址:http://commons.apache.org/proper/commons-io/download_io.cgi ...
  • Oracle SQL:update更新语句总结

    万次阅读 2015-03-28 11:31:40
    Oracle update SQL 语句总结: update 用于修改表中的数据
  • 更改swapfile大小

    万次阅读 2019-12-04 17:46:53
    查看swapfile大小 swapon -s 关闭swapfile sudo swapoff /swapfile 设置swapfile大小为16G sudo dd if=/dev/zero of=/swapfile bs=1M count=16384 设置swap file类型 sudo mkswap /swapfile 启用swap...
  • 文件后缀大全

    万次阅读 2010-08-05 11:23:00
    file extensions with related program associations.a unix library [unix]ada program.a01 arj multi-volume compressed archive (can be 01 to 99).a11 aiim graphic.a3d
  • MultipartFile转File

    万次阅读 多人点赞 2019-06-19 18:45:05
    前端传过来MultipartFile,后端转为file后删除本地缓存文件 后台接收的需要转换为一个File类型的 接受前端文件: MultipartFile file111 = ((MultipartHttpServletRequest) httpServletRequest).getFile("前端传...
  • 文件后缀名大全

    万次阅读 2013-07-06 14:28:21
    .??_ Files ending in "_" are often compressed install files of the same  name (e.g., .EX_ expands to .EXE, .DL_ expands to .DLL, etc.) .A UNIX Library [UNIX]  ADA Program .A01 ARJ Multi-volu
  • 使用File.isFile()方法返回结果是false使用File.exists()方法返回结果是true也就是说如果是我们常见的普通文件,两者是没多少区别的!区别只在于特殊文件中。Use File.exists() when dealing with special files ...
  • file not recognized: File truncated错误: 这种错误一般是编译数据被截断或则编译过程中发生异常退出系统导致数据丢失; 例如: sample.o: file not recognized: File truncated collect2: error: ld returned ...
1 2 3 4 5 ... 20
收藏数 4,731,127
精华内容 1,892,450
关键字:

file