精华内容
下载资源
问答
  • File类
    千次阅读
    2019-06-21 15:21:21

    File类

    java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。

    • 构造方法
      public File(String pathname) :通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
      public File(String parent, String child) :从父路径名字符串和子路径名字符串创建新的 File实例。
      public File(File parent, String child) :从父抽象路径名和子路径名字符串创建新的 File实例。

    • java.io.File类
      文件和目录路径名的抽象表示形式。
      java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用File类对文件和文件夹进行操作
      我们可以使用File类的方法
      创建一个文件/文件夹
      删除文件/文件夹
      获取文件/文件夹
      判断文件/文件夹是否存在
      对文件夹进行遍历
      获取文件的大小
      File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法

      重点:记住这三个单词
      file:文件
      directory:文件夹/目录
      path:路径

    • static String pathSeparator 与系统有关的路径分隔符,为了方便,它被表示为一个字符串。
      static char pathSeparatorChar 与系统有关的路径分隔符。
      static String separator 与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。
      static char separatorChar 与系统有关的默认名称分隔符。
      操作路径:路径不能写死了
      C:\develop\a\a.txt windows
      C:/develop/a/a.txt linux
      “C:”+File.separator+“develop”+File.separator+“a”+File.separator+“a.txt”

    • 绝对路径和相对路径
      绝对路径:从盘符开始的路径,这是一个完整的路径。
      相对路径:相对于项目目录的路径,这是一个便捷的路径,开发中经常使用。

    • 路径:
      绝对路径:是一个完整的路径
      以盘符(c:,D:)开始的路径
      c:\a.txt
      C:\Users\itcast\IdeaProjects\shungyuan\123.txt
      D:\demo\b.txt
      相对路径:是一个简化的路径
      相对指的是相对于当前项目的根目录(C:\Users\itcast\IdeaProjects\shungyuan)
      如果使用当前项目的根目录,路径可以简化书写
      C:\Users\itcast\IdeaProjects\shungyuan\123.txt–>简化为: 123.txt(可以省略项目的根目录)
      注意:
      1.路径是不区分大小写
      2.路径中的文件名称分隔符windows使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠

    • File类的构造器

    1. File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
      参数:
      String pathname:字符串的路径名称
      路径可以是以文件结尾,也可以是以文件夹结尾
      路径可以是相对路径,也可以是绝对路径
      路径可以是存在,也可以是不存在
      创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况

    2. File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
      参数:把路径分成了两部分
      String parent:父路径
      String child:子路径
      好处:
      父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化

    3. File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
      参数:把路径分成了两部分
      File parent:父路径
      String child:子路径
      好处:
      父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化
      父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象

    • File类获取功能的方法

      • public String getAbsolutePath() :返回此File的绝对路径名字符串。
      • public String getPath() :将此File转换为路径名字符串。
      • public String getName() :返回由此File表示的文件或目录的名称。
      • public long length() :返回由此File表示的文件的长度。
    • 判断功能的方法
      public boolean exists() :此File表示的文件或目录是否实际存在。
      public boolean isDirectory() :此File表示的是否为目录。
      public boolean isFile() :此File表示的是否为文件。

    • File类创建删除功能的方法

      • public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。

      • public boolean delete() :删除由此File表示的文件或目录。

      • public boolean mkdir() :创建由此File表示的目录。

      • public boolean mkdirs() :创建由此File表示的目录,包括任何必需但不存在的父目录。

        public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。
        创建文件的路径和名称在构造方法中给出(构造方法的参数)
        返回值:布尔值
        true:文件不存在,创建文件,返回true
        false:文件存在,不会创建,返回false
        注意:
        1.此方法只能创建文件,不能创建文件夹
        2.创建文件的路径必须存在,否则会抛出异常

        public boolean createNewFile() throws IOException
        createNewFile声明抛出了IOException,我们调用这个方法,就必须的处理这个异常,要么throws,要么trycatch

    • public boolean mkdir() :创建单级空文件夹
      public boolean mkdirs() :既可以创建单级空文件夹,也可以创建多级文件夹
      创建文件夹的路径和名称在构造方法中给出(构造方法的参数)
      返回值:布尔值
      true:文件夹不存在,创建文件夹,返回true
      false:文件夹存在,不会创建,返回false;构造方法中给出的路径不存在返回false
      注意:
      1.此方法只能创建文件夹,不能创建文件

    • public boolean delete() :删除由此File表示的文件或目录。
      此方法,可以删除构造方法路径中给出的文件/文件夹
      返回值:布尔值
      true:文件/文件夹删除成功,返回true
      false:文件夹中有内容,不会删除返回false;构造方法中路径不存在false
      注意:
      delete方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎

    目录的遍历

    • File类遍历(文件夹)目录功能
      - public String[] list() :返回一个String数组,表示该File目录中的所有子文件或目录。
      - public File[] listFiles() :返回一个File数组,表示该File目录中的所有的子文件或目录。
      注意:
      list方法和listFiles方法遍历的是构造方法中给出的目录
      如果构造方法中给出的目录的路径不存在,会抛出空指针异常
      如果构造方法中给出的路径不是一个目录,也会抛出空指针异常
    更多相关内容
  • Java基础之File类详解

    千次阅读 多人点赞 2021-01-20 11:44:09
    Java.io.File类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。File 类的实例是不可变的;也就是说,一旦创建,File 对象表示的抽象路径名将永不改变。 重点有三个单词需要记住:file...
     

    Java基础之File类详解

    构造方法

    主要成员方法

    获取功能的方法 

    判断功能的方法

    创建删除功能的方法

    目录的遍历

    案例-文件搜索

    案例-文件搜索(高级玩法)

    创作不易,如果本篇博客对您有一定的帮助,大家记得留言+点赞哦。


    Java.io.File类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。File 类的实例是不可变的;也就是说,一旦创建,File 对象表示的抽象路径名将永不改变。

    重点有三个单词需要记住:file(文件),directory(文件夹),path(路径)

    构造方法

    构造方法摘要

    File(File parent, String child)

              根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

    File(String pathname)

              通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

    File(String parent, String child)

              根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

    //File类的构造函数--练习
    private static void show02(){
         File file= new File("F:\\04Java\\19java","Hello.java");
         System.out.println(file);
    }
    
    private static void show01(){
       File f1= new File("F:\\04Java\\19java");
       System.out.println(f1);//重写了ToString()方法
    
       File f3= new File("b.txt");
       System.out.println(f3);
    }
    private static void show03(){
         File file=new File("F:\\04Java\\19ava");
         File newFile = new File(file,"Hello.java");
         System.out.println(newFile);
    }

    主要成员方法

    获取的方法 

    方法摘要
     StringgetAbsolutePath()
              返回此抽象路径名的绝对路径名字符串。
     StringgetName()
              返回由此抽象路径名表示的文件或目录的名称。
     StringgetPath()
              将此抽象路径名转换为一个路径名字符串。
     longlength()
              返回由此抽象路径名表示的文件的长度。
    //获取文件绝对路径
    private static void show04() {
         File file=new File("F:\\04Java\\19java");
         File absoluteFile=file.getAbsoluteFile();//返回File对象的绝对路径
         System.out.println(absoluteFile);
         File file2=new File("a.txt");
         File absoluteFile2=file2.getAbsoluteFile();//返回File对象的绝对路径
         System.out.println(absoluteFile2);
         System.out.println("____________________________");
    }
    //file1.getName()  获取最后一个路径名
    private static void show02(){
         File file=new File("F:\\04Java\\19java");
         String name=file.getName();//最后的路径名
         System.out.println(name);
    
         File file1=new File("F:\\04Java\\19java\\小小张自由");
         String name1=file1.getName();//最后的路径名
         System.out.println(name1);
    }
    //file.getPath()  构造函数中传递什么值,就返回什么值
    private static void show01(){
         File file=new File("F:\\04Java\\19java");
         String path=file.getPath();//传递的参数是什么,返回值就是什么
         System.out.println(path);
         File file1=new File("b.txt");
         String path1=file1.getPath();
         System.out.println(path1);
    }
     //file.length() 获取文件的大小
    private static void show03(){
         File file=new File("F:\\迅雷下载\\AirtestIDE-win-1.2.6.zip");
         long length=file.length();//文件名的大小,路径错误则为0
         System.out.println(length);//单位字节
    }

    判断的方法

    方法摘要
     booleanexists()
              测试此抽象路径名表示的文件或目录是否存在
     booleanisDirectory()
              测试此抽象路径名表示的文件是否是一个目录。
     booleanisFile()
              测试此抽象路径名表示的文件是否是一个标准文件。
    //用于判断构造函数中给定的路径是否为目录、文件
    public static void main(String[] args){
    	File file = new File("F:\\04Java\\19java");
    	System.out.println(file.exists());//判断文件名是否存在
    	System.out.println(file.isDirectory());//判断是否以文件夹结尾
    	System.out.println(file.isFile());//判断是否以文件结尾
    }
    

    创建删除的方法

    方法摘要
     booleancreateNewFile()
              当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。
     booleandelete()
              删除此抽象路径名表示的文件或目录。
     booleanmkdir()
              创建此抽象路径名指定的目录。
     booleanmkdirs()
              创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。
    //File类中CreateNewFile()方法只能新建文件,创建成功true
    private static void show01()throws IOException{
        File file=new File("F:\\04Java\\19java\\99.txt");
        boolean newFile=file.createNewFile();//只能新建文件,创建成功true
        System.out.println(newFile);
    }
    //File类中Delete()方法
    private static void show03(){
        File file=new File("F:\\04Java\\19java\\HelloJava");
        boolean delete=file.delete();//可以删除文件夹只能是空文件夹
        System.out.println(delete);
    
        File file1=new File("F:\\04Java\\19java\\99.txt");
        boolean delete1=file1.delete();//可以删除文件
        System.out.println(delete1);
        }
    //File类中mkdir()和mkdirs()的方法创建单级、多级目录
    private static void show02(){
        File file=new File("F:\\04Java\\19java\\HelloJava");
        boolean mkdir=file.mkdir();//创建单级目录
        System.out.println(mkdir);
        File file1=new File("F:\\04Java\\19java\\Hello\\Java");
        boolean mkdirs=file1.mkdirs();//创建多级目录
        System.out.println(mkdirs);
    }

     目录的遍历

    方法摘要
     String[]list()
              返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录。
     File[]listFiles()
              返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。
    //file.listFiles();方法返回值是一个File[]
    private static void show02(){
        File file=new File("F:\\04Java\\19java");
        File[]files=file.listFiles();
        for(File file1:files){
            System.out.println(file1);
        }
    }
    
    //file.list();方法返回值是一个String[]
    private static void show01(){
        File file=new File("F:\\04Java\\19java");
        String[] list=file.list();
        System.out.println(list);//地址值
        for(String i:list){
            System.out.println(i);
        }
    }

    案例-文件搜索

         1. 搜索后缀名为.pdf的文件

         2. 目录搜索,无法判断多少级目录,所以使用递归,遍历所有目录。

         3. 遍历目录时,获取的子文件,通过文件名称,判断是否符合条件。

    public class DiGuiDemo3 { 
        public static void main(String[] args) {
            // 创建File对象 
            File dir = new File("E:\\书籍"); 
            // 调用打印目录方法 
            printDir(dir); 
        }
        public static void printDir(File dir) { 
            // 获取子文件和目录 
            File[] files = dir.listFiles(); 
            
            // 循环打印 
            for (File file : files) { 
                if (file.isFile()) { 
                    // 是文件,判断文件名并输出文件绝对路径 
                    if (file.getName().endsWith(".PDF")) {
                        System.out.println("文件名:" + file.getAbsolutePath());
                    }
                }else{ 
                    // 是目录,继续遍历,形成递归 
                    printDir(file); 
                } 
            } 
        } 
    }

    案例-文件搜索(高级玩法)

      使用FileFilter接口或者FilenameFilter接口,是File的过滤器。该接口方法的参数是FIle类的对象。接口中只有一个方法。

    //Sun公司封装的两个文件过滤的接口
    public interface FilenameFilter {
        boolean accept(File dir, String name);
    }
    public interface FileFilter {
        boolean accept(File pathname);
    }

    下面任意一种方式都可以实现文件搜索的功能:方式一使用了 FileFilter接口,方式二使用了FilenameFilter接口。

    以下三种玩法一个使用了接口的实现类,一个使用了Lambda表达式、一个使用了匿名内部类

    public static void main(String[] args) {
        File file=new File("E:\\书籍");
        //System.out.println(file);
        getAllFile(file);
    }
    //以下是三种玩法
    public static void getAllFile(File file) {
    
       //方式一、使用FIleFilter接口的实现类
       File[] files = file.listFiles(new Demo09FileFilterImpl());//实现了FIleFilter接口
       //方式1. 使用Lambda表达式
       File[] files = file.listFiles((pathname)->{
             return pathname.getName().toLowerCase().endsWith(".pdf");//
       });
    
       //方式二、使用FilenameFilter
       File[] files =file.listFiles(new FilenameFilter() {
            @Override     //两个路径
            public boolean accept(File dir, String name) {
                return new File(dir,name).isDirectory()|| name.toLowerCase().endsWith("pdf");
             }
         });
    }

    创作不易,如果本篇博客对您有一定的帮助,大家记得留言+点赞哦。

     

     

     

    展开全文
  • 1、File类 java.io.File类是文件和目录路径名的抽象表示,主要用于文件和目录的创建,查找和删除等操作。 Java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用File类对文件和文件夹进行操作:创建...

    1、File类

    java.io.File类是文件和目录路径名的抽象表示,主要用于文件和目录的创建,查找和删除等操作。
    Java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用File类对文件和文件夹进行操作:创建一个文件/文件夹,删除文件/文件夹,获取文件/文件夹,判断文件/文件夹是否存在,对文件夹进行遍历,获取文件的大小。
    File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法

    重点:记住三个单词
    file:文件
    directory:文件夹/目录
    path:路径

    import java.io.File;
    
    public class Demo01File {
        public static void main(String[] args) {
            String pathSeparator = File.pathSeparator;
            System.out.println(pathSeparator); //; 路径分隔符 windows:分号 linux : 冒号
    
            String separator = File.separator;
            System.out.println(separator); // \ 文件名称分隔符 windows:反斜杠 Linux:正斜杠
        }
    }
    

    2、绝对路径和相对路径

    绝对路径:是一个完整的路径,以盘符开始(c: d:)c:\a.txt
    相对路径:相对指的是相对于当前项目的根目录(可以省略项目的根目录)
    注意:
    1、路径不区分大小写
    2、路径中的文件名称分隔符windows使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠

    3、File类的构造方法

    构造方法:
    public File(String pathname):通过将给定的路径名字字符串转换为抽象路径名来创建新的File实例。
    public File(String parent, String child):从父路径名字符串和子路径字符串创建新的File实例。
    public File(File parent, String child):从父抽象路径和子路径名字符串创建新的File实例。
    代码演示:

    import java.io.File;
    
    public class Demo02File {
        public static void main(String[] args) {
            /*
                File类的构造方法
             */
    //        show02("c:\\","a.txt");
            show03();
        }
    
        /*File(File parent, String child):从父抽象路径和子路径名字符串创建新的File实例
            参数:把路径分成了两部分
                File parent:父路径
                String child :子路径
            好处:
                父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化
                父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象
        */
        private static void show03() {
            File parent = new File("c:\\");
            File file = new File(parent, "hello.java");
            System.out.println(file);
        }
    
        /*
            File(String parent, String child):
                从父路径名字符串和子路径字符串创建新的File实例
            参数:把路径分成了两部分
                String parent:父路径
                String child :子路径
            好处:
                父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化
         */
        private static void show02(String parent, String child) {
            File file = new File(parent,child);
            System.out.println(file);
        }
    
        /*
            File(String pathname) 通过将给定的路径名字字符串转换为抽象路径名来创建新的File实例
            参数:
                String pathname :字符串的路径名称
                路径可以是以文件结尾,也可以是以文件夹结尾
                路径可以是相对路径,也可以是绝对路径
                路径可以是存在的,也可以是不存在的
                创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况
         */
        private static void show01() {
            File f1 = new File("C:\\Game\\Team\\a.txt");
            System.out.println(f1); //重写了Object类的toString方法
    
            File f2 = new File("C:\\Game\\Team");
            System.out.println(f2);
    
            File f3 = new File("a.txt");
            System.out.println(f3); //a.txt
        }
    }
    

    4、File类获取功能的方法

    —public String getAbsolutePath() :返回此file的绝对路径名字符串。
    —public String getPath() :将此File转换为路径名字符串。
    —public String getName() :返回由此File表示的文件或者目录的名称。
    —public long length() :返回由此File表示的文件的长度。
    代码演示:

    import java.io.File;
    
    public class Demo03File {
        public static void main(String[] args) {
            show04();
        }
    
        /*
            —public long length() :返回由此File表示的文件的长度。
            获取的是构造方法指定的文件的大小,以字节为单位
            注意
                文件夹是没用大小概念的,不能获取文件夹的大小
                如果构造方法中给出的路径不存在,那么length方法返回0
         */
        private static void show04() {
            File f1 = new File("C:\\Game\\Team\\aaa.png");
            long length1 = f1.length();
            System.out.println(length1); //499132  488KB
    
            File f2 = new File("C:\\Game\\Team\\aaaaaa.txt");
            long length2 = f2.length();
            System.out.println(length2); // 0 文件不存在
    
            File f3 = new File("C:\\Game\\Team");
            long length3 = f3.length();
            System.out.println(length3); // 0 文件夹没有大小
    
        }
    
        /*
            —public String getName() :返回由此File表示的文件或者目录的名称。
            获取的就是构造方法传递路径的结尾部分(文件/文件夹)
         */
        private static void show03() {
            File f1 = new File("C:\\Game\\Team\\a.txt");
            String name1 = f1.getName();
            System.out.println(name1); //a.txt
    
            File f2 = new File("C:\\Game\\Team");
            String name2 = f2.getName();
            System.out.println(name2); //Team
        }
    
        /*
            —public String getPath() :将此File转换为路径名字符串
            获取的构造方法传递的路径
    
         */
        private static void show02() {
            File f1 = new File("C:\\Game\\Team\\a.txt");
            File f2 = new File("a.txt");
            String path1 = f1.getPath();
            System.out.println(path1); //C:\Game\Team\a.txt
            String path2 = f2.getPath();
            System.out.println(path2); //a.txt
    
            System.out.println(f1); //C:\Game\Team\a.txt
            System.out.println(f1.toString()); //C:\Game\Team\a.txt
        }
    
    
        /*—public String getAbsolutePath() :返回此file的绝对路径名字符串
                获取的构造方法传递的路径
                无论路径是绝对的还是相对的,getAbsolutePath方法返回的都是绝对路径
         */
        private static void show01() {
            File f1 = new File("C:\\Game\\Team\\a.txt");
            String absolutePath1 = f1.getAbsolutePath();
            System.out.println(absolutePath1); //C:\Game\Team\a.txt
    
            File f2 = new File("a.txt");
            String absolutePath2 = f2.getAbsolutePath();
            System.out.println(absolutePath2); //C:\IdeaProject\project02\a.txt
        }
    }
    

    5、File类判断功能的方法

    —public boolean exists( ) :此FIle表示的文件或目录是否实际存在。
    —public boolean isDirectory( ) :此File表示的是否为目录。
    —public boolean isFile( ) :此File表示的是否为文件。
    代码演示:

    import java.io.File;
    
    /*
        —public boolean exists( ) :此FIle表示的文件或目录是否实际存在。
        —public boolean isDirectory( ) :此File表示的是否为目录。
        —public boolean isFile( ) :此File表示的是否为文件。
     */
    public class Demo04File {
        public static void main(String[] args) {
            show02();
        }
    
        /*
            —public boolean isDirectory( ) :此File表示的是否为目录。
            用于判断构造方法中给定的路径是否以文件夹结尾
                是:true
                否:false
            —public boolean isFile( ) :此File表示的是否为文件。
            用于判断构造方法中给定的路径是否以文件结尾
                是:true
                否:false
            注意:
                电脑的硬盘中只有文件/文件夹,两个方法是互斥的
                这两个方法的使用前提路径必须是存在的,否则都返回false
         */
        private static void show02() {
            File f1 = new File("C:\\Game\\Team");
            if(f1.exists()) {
                System.out.println(f1.isDirectory()); //true
                System.out.println(f1.isFile()); //false
            }
    
            File f2 = new File("C:\\Game\\Team\\aaa.png");
            if(f2.exists()) {
                System.out.println(f2.isDirectory()); //false
                System.out.println(f2.isFile()); //true
            }
        }
    
        //—public boolean exists( ) :此FIle表示的文件或目录是否实际存在。
        //用于判断构造方法中的路径是否存在,存在返回true 不存在返回false
        private static void show01() {
            File f1 = new File("C:\\Game\\Team\\aaa.png");
            System.out.println(f1.exists()); //true
    
            File f2 = new File("C:\\Game\\Team\\aaabbb.png");
            System.out.println(f2.exists()); //false
    
        }
    
    }
    

    6、File类创建删除功能的方法

    —public boolean createNewFile():当且仅当具有该名称的文件尚不存在时,创建一个新的空文件
    —public boolean delete():删除由此File表示的文件或目录
    —public boolean mkdir():创建由此FIle表示的目录
    —public boolean mkdirs():创建由此File表示的目录,包含任何必须但不存在的父目录
    代码演示:

    import java.io.File;
    import java.io.IOException;
    
    /*
        —public boolean createNewFile():当且仅当具有该名称的文件尚不存在时,创建一个新的空文件
        —public boolean delete():删除由此File表示的文件或目录
        —public boolean mkdir():创建由此FIle表示的目录
        —public boolean mkdirs():创建由此File表示的目录,包含任何必须但不存在的父目录
     */
    public class Demo05File {
        public static void main(String[] args) throws IOException {
            show04();
        }
    
        /*
            —public boolean delete():删除由此File表示的文件或目录
            此方法可以删除构造方法路径中给出的文件/文件夹
            返回值:布尔值
                true:文件/文件夹删除成功
                false:文件夹中有内容,不会删除返回false,构造方法中路径不存在返回false
            注意:
                delete方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎
         */
        private static void show04() {
            File f1 = new File("c:\\Game\\Team\\aaa.txt");
            boolean b = f1.delete();
            System.out.println(b); //删除成功,返回true
    
        }
    
        private static void show03() {
            File f1 = new File("c:\\Game\\Team\\bbb\\ccc\\ddd\\eee");
            boolean b = f1.mkdirs();
            System.out.println(b); //true 创建多级文件夹成功
        }
    
        /*
            —public boolean mkdir():创建单级空文件夹
            —public boolean mkdirs():既可以创建单级空文件夹,也可以创建多级文件夹
            创建文件夹的路径和名称在构造方法中给出(构造方法的参数)
            返回值:布尔值
                true:文件夹不存在,创建文件夹返回true
                false:文件夹存在,不会创建,返回false;构造方法中给出的路径不存在返回false
            注意:
                此方法只创建文件夹,不能创建文件
         */
        private static void show02() {
            File f1 = new File("c:\\Game\\Team\\aaa");
            boolean b1 = f1.mkdir();
            System.out.println(b1); //创建成功,true
        }
    
        /*
            —public boolean createNewFile():当且仅当具有该名称的文件尚不存在时,创建一个新的空文件
            创建文件的路径和名称在构造方法中给出(构造方法的参数)
            返回值:布尔值
                true:文件不存在,创建文件返回true
                false:文件存在,不会创建,返回false
            注意:
                1、此方法只能创建文件,不能创建文件夹
                2、创建文件的路径必须存在,否则会抛出异常
         */
        private static void show01() throws IOException {
            File f1 = new File("c:\\Game\\Team\\1.txt");
            boolean b1 = f1.createNewFile(); //true 创建成功
            System.out.println(b1);
        }
    }
    

    7、File类遍历(文件夹)目录功能

    File类遍历(文件夹)目录功能
    —public String[ ] list( ) :返回一个String数组,表示该File目录中的所有子文件或目录。
    —public File[ ] listFiles( ) :返回一个File数组,表示该File目录中的所有的子文件或目录。
    注意:
    list方法和listFiles方法遍历的是构造方法中给出的目录
    如果构造方法中给出的目录的路径不存在,会抛出空指针异常
    如果构造方法中给出的路径不是一个目录,也会抛出空指针异常
    代码演示:

    import java.io.File;
    
    public class Demo06File {
        public static void main(String[] args) {
            show02();
        }
    
        /*
        —public File[ ] listFiles( ) :返回一个File数组,表示该File目录中的所有的子文件或目录。
        遍历构造方法中给出的目录,会获取目录中所有文件/文件夹的名称,把文件/文件夹封装为File对象,
        多个File对象存储到File数组中
         */
        private static void show02() {
            File f1 = new File("c:\\Game\\Team");
            File[] files = f1.listFiles();
            for (File file : files) {
                System.out.println(file);
                //c:\Game\Team\1.txt
                //c:\Game\Team\aaa
                //c:\Game\Team\aaa.png
                //c:\Game\Team\bbb
            }
        }
    
        /*
        —public String[ ] list( ) :返回一个String数组,表示该File目录中的所有子文件或目录。
        遍历构造方法中给出的目录,会获取目录中所有文件/文件夹的名称,把获取到的多个名称
        存储到一个String类型的数组中
         */
        private static void show01() {
            File f1 = new File("c:\\Game\\Team");
            String[] list = f1.list();
            for (String s : list) {
                System.out.println(s);
                //1.txt
                //aaa
                //aaa.png
                //bbb
            }
        }
    }
    
    展开全文
  • Java基础之File类和String类

    千次阅读 2021-07-25 20:43:20
    File类 计算机中万物皆文件 获取File类 获取File类有三种方式[Constructor构造方法] File(String pathName); 根据对应的文件路径创建获取对应的File类对象,可以是文件,也可以是文件夹 File(String parent, ...

    File类

    计算机中万物皆文件

    获取File类

    获取File类有三种方式[Constructor构造方法]

    • File(String pathName);

      根据对应的文件路径创建获取对应的File类对象,可以是文件,也可以是文件夹

    • File(String parent, String child);

      根据对应的父目录文件夹路径,以及子文件名或者子文件夹名,创建对应的File类对象

    • File(File parent, String child);

      根据对应的父目录文件夹File类对象,以及子文件名或者子文件夹名,创建对应的File类对象

    路径

    • 相对路径

      . 当前工作目录

      … 上级目录

    • 绝对路径

      image-20210723090128831

    分隔符

    image-20210723090142342

    File.separatorChar

    ​ 根据当前系统区分不同的分隔符

    image-20210723094921814

    创建文件和文件夹

    • boolean createNewFile();

      通过File类对象调用,创建对应File类对象中保存的路径的普通文件

      创建成功返回True,创建失败返回False

      返回False的原因:

      1. 路径不合法
      2. 对应的文件夹没有写入权限
      3. 对应当前的文件已经存在
    • boolean mkdir();

      通过File类对象调用,创建对应的File类对象中保存路径的文件夹

      创建成功返回True,创建失败返回False

      返回False的原因:

      1. 路径不合法
      2. 对应的文件夹没有写入权限
      3. 对应当前的文件夹已经存在
    • boolean mkdirs(path);

      创建一个嵌套的文件夹

    • boolean renameTo(File dest);

      通过File类对象调用,转为目标File类对象dest

      文件/文件夹移动,重命名

    实例1:

    package obj_file;
    
    import java.io.File;
    import java.io.IOException;
    
    
    public class Demo1 {
    	public static void main(String[] args) throws IOException{
    		File file = new File("D:\\JavaCode\\test");
    		
    		// 需要抛出异常,创建文件
    		File file2 = new File(file, "1.txt");
    		System.out.println(file2.createNewFile());
    		
    		// 创建文件夹
    		File file3 = new File(file, "aaa");
    		System.out.println(file3.mkdir());
    		
    		// 创建一个嵌套文件夹
    		File file4 = new File("D:\\JavaCode\\test\\a\\b\\c\\d");
    		System.out.println(file4.mkdirs());
    	}
    }
    

    image-20210723101717510

    效果:

    image-20210723101821348

    image-20210723101808117

    实例2:

    package obj_file;
    
    import java.io.File;
    import java.io.IOException;
    
    
    public class Demo1 {
    	public static void main(String[] args) throws IOException{
    		File file = new File("D:\\JavaCode\\test");
    		
    		// 需要抛出异常,创建文件
    		File file2 = new File(file, "1.txt");
    		System.out.println(file2.createNewFile());
    		
    		// 文件重命名,相当于覆盖源文件,但是文件的创建时间和修改时间等参数不改变
    		file2.renameTo(new File("D:\\JavaCode\\test\\test.txt"));
    	}
    }
    

    修改成功:

    image-20210723102144574

    删除文件或者文件夹

    • boolean delete();

      通过File类对象调用,删除对应的文件或者文件夹

      要求:

      1. 删除的文件或者文件夹都是直接抹掉数据,不是放入回收站
      2. 无法删除非空文件夹,文件夹中存在其他内容无法整体删除
    • void deleteOnExit();

      程序退出时删除对应的文件或者文件夹

      可用于删除程序运行过程中,留下的日志文件,缓存文件等

    		File file = new File("D:\\JavaCode\\test\\test.txt");
    		System.out.println(file.delete());
    		
    		File file2 = new File("D:\\JavaCode\\test\\a");
    		file2.deleteOnExit();
    

    文件属性判断

    • boolean isFile();

      判断是否是一个普通文件

    • boolean isDirectory

      判断是否是一个文件夹

    • boolean isAbsolute();

      判断是否使用了绝对路径

    • boolean isHidden();

      判断是否是隐藏文件

    • boolean exists();

      判断文件是否存在

    package obj_file;
    
    import java.io.File;
    
    public class Demo2 {
    	public static void main(String[] args) {
    		// 判断是否是一个普通文件
    		System.out.println(new File("D:\\JavaCode\\test\\1.txt").isFile());
    		
    		// 判断是否是一个文件夹
    		System.out.println(new File("D:\\JavaCode\\test\\1.txt").isDirectory());
    		System.out.println(new File("D:\\JavaCode\\test").isDirectory());
    		
    		// 判断是否使用了绝对路径,注意20.txt及时不存在结果也是true,只判断是否是绝对路径
    		System.out.println(new File("D:\\JavaCode\\test\\1.txt").isAbsolute());
    		System.out.println(new File("D:\\JavaCode\\test\\20.txt").isAbsolute());
    
    		// 判断是否是隐藏文件
    		System.out.println(new File("D:\\JavaCode\\test\\2.txt").isHidden());
    		
    		// 判断文件是否存在
    		System.out.println(new File("D:\\JavaCode\\test\\2.txt").exists());
    	}
    }
    

    获取文件属性

    • String getPath();

      获取File类对象保存的路径

    • String getName();

      获取当前File类对象中保存的文件名或者文件夹名

    • String getParent();

      获取当前File类对象对应文件或文件夹的父目录路径

    • String getAbsolutePath();

      获取当前File类对象对应文件或者文件夹的绝对路径

    常用方法:

    • long lastModified();

      获取文件最后一次修改时间,返回值是一个时间戳类型,从1970年01月01日00:00:00到现在的秒数

    • long length();

      获取文件的大小,字节数

    package obj_file;
    
    import java.io.File;
    
    public class Demo3 {
    	public static void main(String[] args) {
    		File file = new File("D:\\JavaCode\\test\\test.txt");
    		
    		System.out.println(file.getPath());
    		System.out.println(file.getParent());
    		System.out.println(file.getName());
    		System.out.println(file.getAbsolutePath());
    		
            // 如果找不到文件,返回时间0
    		System.out.println(file.lastModified());
            // 文件夹返回0L,找不到返回0L
    		System.out.println(file.length());
    	}
    }
    

    image-20210723141220253

    package obj_file;
    
    import java.io.File;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class Demo3 {
    	public static void main(String[] args) {
    		File file = new File("D:\\JavaCode\\test\\test.txt");
    		
    		long lastModified = file.lastModified();
    		System.out.println(lastModified);
    		
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
    		String format = simpleDateFormat.format(new Date(lastModified));
    		
    		System.out.println(format);
    	}
    }
    

    image-20210723142506337

    列表方法

    • static File[] listRoots();

      通过File类对象调用,有且针对于Windows操作系统有效,获取当前电脑内所有根盘符对象,如果是Linux,UNIX,macos则无效

    • File[] listFiles();

      通过File类对象调用,获取当前File类对象对应文件夹下的所有子文件或者子文件夹的File类对象数组

    • String[] list();

      通过File类对象调用,获取当前File类对象对应文件夹下的所有子文件或者子文件夹的String类型文件名或者文件夹名称数组

    实例:

    package obj_file;
    
    import java.io.File;
    
    public class Demo4 {
    	public static void main(String[] args) {
    		File[] listRoots = File.listRoots();
    		
    		/*
    		 * for (数据类型 变量名:数组/集合) {
    		 * }
    		 */
    		for(File file : listRoots) {
    			System.out.println(file);
    		}
    		
    		System.out.println("--------------");
    		File file = new File("D:\\JavaCode\\test");
    		File[] listFiles = file.listFiles();
    		for (File file2 : listFiles) {
    			System.out.println(file2);
    		}
    		
    		System.out.println("--------------");
    		String[] liStrings = file.list();
    		for (String string : liStrings) {
    			System.out.println(string);
    		}
    	}
    }
    

    输出:

    image-20210724093741298

    FilenameFilter文件名过滤器

    匿名内部类实现方法:

    package obj_file;
    
    import java.io.File;
    import java.io.FilenameFilter;
    
    public class Demo5 {
    	public static void main(String[] args) {
    		File file = new File("D:\\JavaCode\\test");
    
    		// 使用匿名内部类的匿名对象直接作为方法的参数
    		File[] listFiles = file.listFiles(new FilenameFilter() {
    			@Override
    			public boolean accept(File dir, String name) {
    				/*
    				 * dir是当前操作的文件夹类对象 name是当前文件夹下的子文件或者子文件夹 获取对应的Java文件 1.判断是不是普通文件
    				 * 2.判断当前文件夹是不是以.java结尾的
    				 */
    				return new File(dir, name).isFile() && name.endsWith(".java");
    			}
    		});
    
    		for (File file2 : listFiles) {
    			System.out.println(file2);
    		}
    	}
    }
    

    lambda表达式方法实现:

    jdk1.8新特征

    	File[] listFiles = file.listFiles((dir, name) -> 
    		new File(dir, name).isFile() && name.endsWith(".java")
    		);
    
    	for (File file2 : listFiles) {
    		System.out.println(file2);
    	}
    

    image-20210724100828034

    常用API-String

    String字符串冗余问题

    image-20210724101938182

    复习实例:

    将文件按照不同的文件后缀名归类,如:Java后缀的放到Java文件夹,doc文件放到doc文件夹

    image-20210724195026035

    image-20210724201510679

    package obj_file;
    
    import java.io.File;
    import java.io.IOException;
    
    public class Demo7 {
    	public static void main(String[] args) throws IOException{
    		// 目标文件夹的File类对象
    		File file = new File("D:\\JavaCode\\demo");
    		
    		// 需要创建的文件夹类对象
    		File toBeCreateFile = null;
    		
    		// 判断file是否是文件夹,不是文件夹就退出程序
    		if(!file.isDirectory()) {
    			return;
    		}
    		
    		// 当前文件夹已经完成归档,不需要再次归档
    		if(new File(file,"1.lock").exists()) {
    			System.out.println("已经归档完成");
    			return;
    		}
    		
    		// 当前文件夹下的所有子文件和子文件夹File类对象
    		File[] listFiles = file.listFiles();
    		
    		// 遍历listFiles对象数组
    		for (File srcFile : listFiles) {
    			// 如果是文件,获取后缀名
    			if(srcFile.isFile()) {
    				String fileName = srcFile.getName();
    				String upperSuffix = fileName.substring(fileName.lastIndexOf(".") + 1)
    						.toUpperCase();
    				toBeCreateFile = new File(file, upperSuffix);
    			} else {
    				// 如果是文件夹,则创建子文件夹最后统一移进去
    				toBeCreateFile = new File(file, "subDir");
    			}
    			
    			// 创建文件夹
    			toBeCreateFile.mkdir();
                
    			// 移动文件
    			srcFile.renameTo(new File(toBeCreateFile, srcFile.getName()));
    		}
    		
    		// 创建锁文件
    		new File(file, "1.lock").createNewFile();
    	}
    }
    

    执行效果:

    image-20210724204032508

    String类

    String比较

    image-20210725102630298

    双等于号(==)更多的是比较地址,而.equals比较的是数值,推荐使用equals

    推荐使用:

    String str1 = "test"
    

    比较方法

    获取方法

    • int length();

      获取字符串长度

    • char charAt(int index);

      获取String字符串中指定下标位置的char类型字符,如果index超出有效范围,抛出异常StringIndexOutOfBoundException

    • int indexOf(char ch);

    • int indexOf(String str);

    • int indexOf(char ch, int fromIndex);

    • int indexOf(String str, int fromIndex);

      这四个方法都是获取指定元素所在的下标位置,元素可以是char类型字符,也可以是字符串,找出指定元素在字符串中第一次出现的位置,也可以通过fromIndex约束,从哪个位置开始找

    • int lastIndexOf(char ch);

    • int lastIndexOf(String str);

    • int lastIndexOf(char ch, int fromIndex);

    • int lastIndexOf(String str, int fromIndex);

      这四个方法都是获取指定元素所在的下标位置,元素可以是char类型字符,也可以是字符串,找出指定元素在字符串中最后一次出现的位置,也可以通过fromIndex约束,从哪个位置开始找

    找到返回位置(从0开始),找不到返回负数

    实例:

    package obj_string;
    
    public class Demo1 {
    	public static void main(String[] args) {
    		String str = "ocean is a good boy";
    		
    		System.out.println("str的长度:" + str.length());
    		System.out.println("下标为4的字符为:" + str.charAt(4));
    		System.out.println("===========================================");
    
    		System.out.println("字符o所在的位置为:" + str.indexOf("o"));
    		System.out.println("字符串oo所在的位置为:" + str.indexOf("oo"));
    		System.out.println("字符o从5开始后查找第一次出现的位置为:" + str.indexOf("o", 5));
    		System.out.println("字符串oo从5开始后查找第一次出现的位置为:" + str.indexOf("oo", 5));
    		System.out.println("===========================================");
    
    		System.out.println("字符o所在的位置为:" + str.lastIndexOf("o"));
    		System.out.println("字符串oo所在的位置为:" + str.lastIndexOf("oo"));
    		System.out.println("字符o从5开始后查找最后一次出现的位置为:" + str.lastIndexOf("o", 5));
    		System.out.println("字符串oo从5开始后查找最后一次出现的位置为:" + str.lastIndexOf("oo", 5));
    		System.out.println("字符串o从5开始后查找最后一次出现的位置为:" + str.lastIndexOf("o", 5));
    		System.out.println("===========================================");
    		
    		System.out.println("字符串a从5开始后查找第一次出现的位置为:" + str.lastIndexOf("a", 5));
    
    	}
    }
    

    image-20210725110823127

    注意:lastIndexOf(String str, int fromIndex);加了fromIndex就是从后往前数

    判断方法

    • boolean endsWith(String str);

      判断当前字符串是不是以指定字符串结尾

    • boolean isEmpty();

      判断字符串是否为空 ""空串

      JDK1.6之后,null不能读取,不能写入,不能调用方法

    • boolean equals(Object obj);

      继承重写Object类内的方法,完成字符串要求的比较方法

    • boolean equalsIgnoreCase(String str);

      不区分大小写比较

    • boolean contains(String str);

      判断字符串是否存在

    package obj_string;
    
    public class Demo2 {
    	public static void main(String[] args) {
    		String str = "ocean";
    		
    		System.out.println("str.isEmpty:" + str.isEmpty());
    		System.out.println("str.endsWith:" + str.endsWith("an"));
    		System.out.println("abcdefg".equals("abcdefg"));
    		System.out.println("AbCdefg".equalsIgnoreCase("abcdefg"));
    		System.out.println(str.contains("an"));
    	}
    }
    

    image-20210725133505652

    转换方法

    数组转换成字符串

    • String(char[] arr);

      使用字符数组中内容创建一个字符串对象

    • String(char[] arr, int offset, int length)

      使用字符数组中内容创建一个字符串对象,offset是从char类型数组中指定下标位置开始获取数据,获取的数据长度为length

    • static String valueOf(char[] arr);

      通过类名调用的静态方法,实际执行的是String(char[] arr, int offset, int length);

    • char[] toCharArray();

      返回当前字符串对应的字符数组

    package obj_string;
    
    public class Demo3 {
    	public static void main(String[] args) {
    		char[] arr = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    		
    		String str1 = new String(arr);
    		System.out.println(str1);
    		
    		String str2 = new String(arr, 2, 5);
    		System.out.println(str2);
    		
    		String str3 = String.valueOf(arr);
    		System.out.println(str3);
    		
    		String str4 = String.valueOf(arr, 2, 5);
    		System.out.println(str4);
    	}
    }
    

    输出结果:

    image-20210725135553451

    字符串转换成数组:

    package obj_string;
    
    import java.util.Arrays;
    
    public class Demo3 {
    	public static void main(String[] args) {
    		char[] charArray = "这是一个字符串".toCharArray();
    		System.out.println(Arrays.toString(charArray));
    	}
    }
    

    image-20210725135809003

    其他方法

    • String replace(char oldChar, char newChar)

      替换,替换不会修改原始的字符串,会创建一个新的字符串返回,将所有就字符替换为新字符或字符串

    • String[] split(String regex)

      按照指定的字符串切割当前字符串

    • String substring(int beginIndex);

      从指定位置开始,截取子字符串,到字符串末尾

    • String substring(int beginIndex, int endIndex)

      截取字符串从beginIndex位置开始到endIndex位置结束,要头不要尾,左闭右开

    • String toUpperCase()

      字符串转换成大写

    • String toLowerCase()

      字符串小写转大写

    • String trim()

      去除字符串两边的空格

    实例:

    package obj_string;
    
    import java.util.Arrays;
    
    public class Demo4 {
    	public static void main(String[] args) {
    		String string = "abcabcabc";
    		
    		System.out.println(string.replace('a', 'A'));
    		System.out.println(string.replace("a", "AAA"));
    		System.out.println(string);
    		
    		String[] strings = "a,b,c,d".split(",");
    		System.out.println(Arrays.toString(strings));
    		
    		System.out.println(string.substring(2));
    		System.out.println(string.substring(2, 5));
    		
    		System.out.println(string.toUpperCase());
    		System.out.println("AAAA".toLowerCase());
    		
    		System.out.println("      ocean   ocean     ");
    		System.out.println("      ocean   ocean     ".trim());
    	}
    }
    

    执行结果

    image-20210725145012059

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

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

    万次阅读 多人点赞 2019-04-24 17:10:48
    File类简介   在 Java 中,File 类是 java.io 包中唯一代表磁盘文件本身的对象。File 类定义了一些与平台无关的方法来操作文件,File类主要用来获取或处理与磁盘文件相关的信息,像文件名、 文件路径、访问权限和...
  • 详述java的File类常用方法

    千次阅读 多人点赞 2019-08-21 17:17:27
    File类File类代表一个特定的文件或者目录(文件夹),并提供了若干方法对该文件或目录进行操作。 File类构造方法: 常用的有三种: 1、File(String pathname):通过路径名创建一个新 File 实例。 2、File(File ...
  • File类遍历文件夹

    千次阅读 2022-02-13 15:04:05
    File类便利文件夹 */ public static void main(String[] args) { File file = new File("E:\\aaaa"); printFile(file); } public static void printFile(File file){ File[] files = file.listFiles()
  • Java中的File类和IO流

    万次阅读 多人点赞 2019-08-19 20:40:38
    1.File:翻译是文件,用于表达java中的路径名。 2.路径:用于表示文件或者文件夹在当前系统中的位置 3.路径的分类: 绝对路径 相对路径 4.绝对路径:没有任何的歧义,也没有任何的前提条件 Windows,从盘符开始的...
  • Java-IO流——File类介绍

    千次阅读 2018-10-23 17:02:17
    File类概述 java.io.File代表与平台无关的文件或目录。也就是说可以通过File类在Java程序中操作文件或目录。 File类只能用来操作文件或目录(包括新建、删除、重命名文件和目录等操作),但不能用来访问文件中的...
  • File类——JAVA实现批量修改文件名称

    千次阅读 2021-02-27 20:13:18
    } } } 总结:用好File类方法和String类字符串拼接,基本都可以解决有一定规律的文件批量重命名的问题 String类可能使用的方法 substring(int beginIndex) 截取从beginIndex到末尾的字符串并返回 substring(int ...
  • Java基础之输入/输出流,File类

    千次阅读 2018-05-15 18:47:12
    流: 流的概念:流是一组有序的数据序列,根据操作的类型,可分为输入流和输出流 I/O(Input/Output)流提供一条通道程序,可以使用这条通道...
  • File类的基本使用1.1 文件操作1.1.1 创建新文件1.1.2 删除文件1.1.3 路径分隔符1.2 目录操作1.2.1 取得父路径与父File对象1.2.2 创建目录1.3 取得文件或者目录的信息(大小、最后修改日期)2. IO流2.1 流的操作过程...
  • Java中File类-9-File类的判断功能

    千次阅读 2018-07-05 23:53:30
    本篇来学习File类的判断功能,主要的判断有:判断是否是目录,判断是否是文件,判断是否存在,判断是否可读,判断是否可写,判断是否隐藏。前面我们知道了判断是否存在这个方法,下面我们一次学习其他方法。1.判断...
  • File类详解

    千次阅读 2018-06-29 18:32:33
    1.java.io.File类是java中很常见的一个类。该类有一下特性: (1)封装了文件或路径。 (2)不能用来创建文件,即在程序中创建一个File对象,并不会在机器上创建一个文件(感兴趣的同学可以去实践一下)。那创建的...
  • Java中File类-10-File类的的获取功能

    千次阅读 2018-07-08 00:02:19
    接着来学习Java中的File类的方法,这篇来学习获取功能,也就是API文档中看到的getxxx方法。主要有获取绝对路径,获取路径,获取名称,获取长度,字节数,获取最后一次修改时间,毫秒值,获取指定路径下所有文件或者...
  • C++ File类(文件目录操作)

    万次阅读 2019-03-14 17:20:12
    C++的file操作很麻烦,刚开始用windowAPI写,后来才发现io.h库里提供了文件目录的操作,所以下面只是根据这些操作,封装出一个file类,可能有漏洞(小白),有问题的话可以联系我做一些修改 注意:C++17中提供了...
  • Java中File类-7-File类和构造方法

    千次阅读 2018-07-05 00:12:40
    在Java中,File类的相关操作是很多,程序的业务代码一般就是直接操作数据。数据主要是来源数据库或者各种各样的文件类型。这篇开始,用几篇文章来记录学习File类的过程。在Selenium自动化测试中,我们用到过File类来...
  • Java将电脑中的文件和文件夹目录封装为了一个File类 可以使用File类对文件和文件夹进行操作 可以使用File的方法来: 创建一个文件/文件夹 删除文件/文件夹 获取文件/文件夹 判断文件/文件夹是否存在 对文件夹进行...
  • File类创建文件

    千次阅读 2019-04-17 19:46:56
    File类是java.io包下代表与java平台无关的文件和目录的类。在程序中操作文件和目 录,就是使用File类来完成。注意,不管是文件还是目录都是使用File来操 作的,File能新建、删除、重命名文件和目录,但是File不能...
  • Java输入/输出——File类详解

    千次阅读 2019-02-28 00:39:41
    本文主要讲述了Java的输入和输出(IO)方面的内容,IO是...Java的IO通过Java.IO 包下的和接口来支持,主要包括输入/输出两种IO流,每种输入/输出流又可以分为字节流和字符流两大,其中字节流以自己为单位来处...
  • File类的概述和构造方法 A:File类的概述 查看API 文件和目录路径名的抽象表示形式 这个File类可以用来表示文件,也可以用来表示目录 B:构造方法 File(String pathname):根据一个路径得到File对象 File(String parent...
  • c# - File类(读取文件)

    千次阅读 2020-10-14 19:53:18
    File类 下图是File类所在的命名空间;且从下边可看出File类是一个静态类。 File静态类的方法 (1)File.Create( string path) 在指定路径中创建或覆盖一个文件(注意:如果指定路径下已经有此文件,那么原有...
  • File类的定义及常用方法

    千次阅读 2019-08-07 14:40:53
    File类的定义:文件和目录路径名的抽象表示形式。 功能: 一个File对象可以代表一个文件或目录, 可以实现获取文件和目录属性等功能, 可以实现对文件和目录的创建、删除等功能。 注意: File不能访问文件内容...
  • 一: 包 import java.io.File; import java.io.IOException;
  • Android file类使用详解

    万次阅读 2018-07-16 10:32:11
    一.Android file类 在开发Android应用时免不了会跟文件打交道,本篇文章记录总结自己常用到的文件操作,数据的存储有多种方式,比如数据库存储、SharedPreferences存储、文件存储等;这里我们将要介绍最简单的文件...
  • Java.io.File类的使用

    万次阅读 2019-04-15 12:18:19
    在一个程序员编程生涯的过程中,File类的使用是不可跨越的基础,因为有些应用场景导致程序员们必须掌握常用类的使用,比如说文件上传,用户上传附件,程序则要把文件保存到指定位置,从服务器下载文件到指定位置,...
  • Java----File类详解

    千次阅读 2017-02-07 23:32:38
    File类 构造方法 创建文件/文件夹 删除文件/文件夹 修改文件 对文件进行判断 获取文件属性 搜索文件 文件过滤
  • Java:File类、递归、查找文件

    千次阅读 2018-09-15 17:27:46
    1、File类-概述 1)java.io.File 这个类可以表示磁盘上的一个文件/目录,可以获取文件/目录的一些属性信息: 文件/目录的名字 文件的大小 文件/目录的最后修改时间 文件/目录是否可读、是否可写 2...
  • File类File [] listFiles() (File Class File[] listFiles()) This method is available in package java.io.File.listFiles(). 软件包java.io.File.listFiles()中提供了此方法。 This method is used to return ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,852,817
精华内容 741,126
关键字:

file类

友情链接: CDFTSVM-master.zip