JavaSE 面向对象程序设计 文件File 介绍练习加千行代码详解

已于 2024-06-15 13:36:10 修改
阅读量8.3k 收藏 13
点赞数 42
分类专栏： # JavaSE 文章标签： java 开发语言 算法 java-ee
于 2024-05-27 14:43:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30500575/article/details/139236954
版权

介绍

在Java中，File类是用于表示文件和目录路径的抽象。它提供了一组方法来创建、删除、重命名、检查文件/目录的存在性、以及查询文件/目录的属性等功能。File类可以用于执行文件系统操作，如创建新文件、删除文件、检查文件是否存在等。

目的是

把字符串先表示为路径

然后转化成File对象

去调用里面的方法

通过父级路径和子级路径拼接的方法

或者是

\ 在Java里是转义字符

字符串和文件拼接

小结

File对象表示路径，可以是文件，也可以是文件夹

这个路径是可以存在的，也可以是不存在的

绝对路径是带盘符的

相对路径是不带盘符的，默认到当前项目下去寻找

常见的成员方法

判断和获取

提前创建了文件

三步走

判断是否存在

判断是否为文件

判断是否为文件夹

import java.io.File;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        //对文件进行判断
        File f1=new File("E:\\新建文件夹\\新建文本文档.txt");

        System.out.println(f1.exists());
        //判断f1文件夹是否存在

        System.out.println(f1.isDirectory());
        //如果f1是文件夹方法返回值是true

        System.out.println(f1.isFile());
        //如果f1是文件方法返回值是true

        
        //对文件夹进行判断
        File f2=new File("E:\\新建文件夹\\新建文件夹");
        System.out.println(f2.exists());//true
        System.out.println(f2.isDirectory());//true
        System.out.println(f2.isFile());//false

        
        //如果文件不存在
        File f3=new File("E:\\新建文件夹\\我不存在");
        System.out.println(f3.exists());//false
        System.out.println(f3.isDirectory());//false
        System.out.println(f3.isFile());//false
    }
}

返回文件的大小 单位是字节

不能获取文件夹的大小，返回的结果和硬件有关

如果我们要获取一个文件夹的大小

需要把这个文件夹里的所有文件大小都累加到一起

import java.io.File;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        File f1=new File("E:\\新建文件夹\\新建文本文档.txt");
        File f2=new File("E:\\新建文件夹\\新建文件夹");

        //返回文件的大小(字节数量)
        System.out.println(f1.length());

        //返回文件夹的大小(获取到的是0，因为length方法只能获取文件的大小)
        System.out.println(f2.length());
        
    }
}

获取文件的绝对路径

如果文字前写了模块名

会进行两次查找，即在当前项目下先寻找模块，在寻找文件

不写的话会在当前模块下直接寻找文件

import java.io.File;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        File f1=new File("E:\\新建文件夹\\新建文本文档.txt");
        File f2=new File("文字.txt");

        //获取文件的绝对路径
        System.out.println(f1.getAbsolutePath());
        System.out.println(f2.getAbsolutePath());
    }
}

获取定义文件对象使用的路径

获取创建File对象时，括号里写的东西

import java.io.File;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        File f1=new File("E:\\新建文件夹\\新建文本文档.txt");
        File f2=new File("文字.txt");

        //获取定义文件时使用的路径
        System.out.println(f1.getPath());
        System.out.println(f2.getPath());
    }
}

获取文件名称

扩展名，后缀名也会显示

但如果是文件夹，只会返回文件夹的名字，而不会返回后缀名，扩展名

import java.io.File;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        File f1=new File("E:\\新建文件夹\\新建文本文档.txt");
        File f2=new File("文字.txt");

        //获取名称
        System.out.println(f1.getName());
        System.out.println(f2.getName());
    }
}

返回文件的最后修改时间

获取的是时间的毫秒值

还是要把他变成字符串表示的时间 yyyy年MM月dd日

import java.io.File;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        File f1=new File("E:\\新建文件夹\\新建文本文档.txt");
        File f2=new File("文字.txt");

        //获取最后一次修改时间的毫秒值
        System.out.println(f1.lastModified());
        System.out.println(f2.lastModified());
    }
}

拓展 把毫秒值转换成表示的时间

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        File f1=new File("文字.txt");

        //获取毫秒值
        System.out.println(f1.lastModified());

        long time=f1.lastModified();

        //获得Date对象
        Date date=new Date(time);

        //获取SimpleDateFormat对象
        //可以解析时间变成我们自己喜欢的格式
        //先写解析式
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM--dd HH:mm:ss");

        //把参数传进去,获得字符串
        String t=sdf.format(date);

        System.out.println(t);

    }
}

获取并遍历

最重要的一个方法

获取文件夹里面所有的内容 包括：文件 文件夹 隐藏的文件

把内容放到数组中进行返回 这个数组是file类型的数组

import java.io.File;

public class Main {
    public static void main(String[] args) {
        File f=new File("D:\\新建文件夹");
        File file[]=f.listFiles();
        for (File file : file) {
            //file表示文件夹里的每一文件或者文件夹
            System.out.println(file);
        }
    }
}

当调用者File表示的路径不存在的时候 返回null

当调用者File表示的路径是文件时 返回null

当调用者File表示的路径是一个空文件夹时 返回一个长度为0的数组

当调用者File表示的路径是一个有内容的文件夹时 将里面的所有文件和文件夹的路径放到File数组中进行返回

当调用者File表示的路径是一个有隐藏文件的文件夹时 将里面的所有文件和文件夹的路径房贷File数组中返回 包括隐藏文件

当调用者File表示的路径是需要权限才能访问的文件夹时 返回null

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class Main {
    public static void main(String[] args) {
        File f=new File("D:\\新建文件夹");

        //遍历盘符
        File arr1[]=File.listRoots();
        for(File f1:arr1) System.out.println(f1);


        /*-----------------------------------------*/
        //获取当前路径下所有的内容 带拓展名
        String arr2[]=f.list();
        for(String str:arr2) System.out.println(str);


        /*-----------------------------------------*/
        //利用文件名过滤器获取当前路径下所有的内容
        String arr3[]=
        f.list(new FilenameFilter() {
            @Override
            //形参表示文件夹里每一个文件或者文件夹的路径
            public boolean accept(File dir, String name) {
                File src=new File(dir,name);
                //返回值表示当前路径是否保留 保留为true 不保留为false
                return src.isFile()&&name.endsWith(".txt");
            }
        });
        for(String str:arr3) System.out.println(str);

        //转化成Lambda表达式
        f.list((dir, name) -> {
            File src=new File(dir,name);
            return src.isFile()&&name.endsWith(".txt");
        });


        /*-----------------------------------------*/
        File arr4[]=f.listFiles(new FileFilter() {
            @Override
            //形参是完整的每一个文件或者文件夹的路径
            public boolean accept(File pathname) {
                return true;
            }
        });

        //转化成Lambda表达式
        File arr5[]=f.listFiles(pathname -> true);


        /*-----------------------------------------*/
        File arr6[]=f.listFiles(new FilenameFilter() {
            @Override
            //第一个形参表示父级路径 第二个形参表示子级路径
            public boolean accept(File dir, String name) {
                return false;
            }
        });

        //第一个形参表示父级路径 第二个形参表示子级路径
        File arr7[]=f.listFiles((dir, name) -> name.endsWith(".txt"));

    }
}

创建文件夹

要求在当前文件夹下创建一个a.txt文件

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        File f=new File("D:\\新建文件夹");
        //如果文件已经存在,则创建失败
        f.mkdirs();
        File src = new File(f,"a.txt");
        boolean b=src.createNewFile();
        if(b) System.out.println("创建成功");
        else System.out.println("文件已经存在,创建失败");
    }
}

单个文件夹查找文件

查找某一个文件夹中，是否有txt结尾的文本文档

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        File f=new File("D:\\新建文件夹");
        System.out.println(have(f));
    }
    public static boolean have(File file){
        //进入文件夹，获取里面的所有内容
        File file1[]=file.listFiles();
        //遍历数组获取里面的每一个元素
        for (File f : file1) {
            //f依次表示文件夹里每一个文件或者是文件夹路径
            if(f.isFile()&&f.getName().endsWith(".txt"))
                return true;
        }
        return false;
    }
}

多个文件夹查找文件

找到电脑中所有以avi结尾的电影

搜索所有盘符 要考虑子文件夹

把大问题拆分，拆到某一个文件夹不包含其他文件夹为止

用递归来实现

找到子文件夹了就再扔到递归里面

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //将盘符获取到数组里
        File arr[]=File.listRoots();
        //通过增强for循环来将数组里的每一个文件对象作为参数传入find函数
        for (File f:arr)find(f);
    }

    public static void find(File file){
        //进入文件夹，获取里面的所有内容
        File file1[]=file.listFiles();
        //判断文件夹是否为空 如果不是空文件夹则进入
        if (file1!=null){
            //遍历文件夹
            for(File f:file1){
                //如果是文件
                if(f.isFile()){
                    //获取文件名并进行判断
                    String name=f.getName();
                    if(name.contains(".txt"))
                        System.out.println(f);
                }
                //如果是文件夹 采用递归的方式
                else {
                    find(f);
                }
            }
        }
    }
}

删除一个多级文件夹

如果我们要删除一个有内容的文件

先删除一个文件夹里的所有内容

再删除自己

其中删除不了无法直接删除的内容(在其他文件中已打开或是没有访问权限等等)

import java.io.File;

public class Main {
    public static void main(String[] args) {
        File file=new File("D:\\新建文件夹");
        delete(file);
    }
    public static void delete(File src){
        //把文件夹内部所有的文件和文件夹放到数组里面去
        File files[]=src.listFiles();
        //遍历每一个文件
        for(File file:files){
            if(file.isFile())//如果是文件,直接删除
                file.delete();
            else delete(file);//如果是文件夹,递归
        }
        src.delete();
    }
}

统计文件夹的大小

统计一个文件夹的总大小

文件夹的总大小说白了就是文件夹里所有文件的大小

import java.io.File;
import java.util.GregorianCalendar;

public class Main {
    //public static long len=0;//定义在外面

    public static void main(String[] args) {
        File file=new File("D:\\新建文件夹");
        System.out.println(getlen(file));
    }
    public static long getlen(File src){
        long len=0;
        //定义变量进行累加
        //得到每一个文件夹
        File files[]=src.listFiles();
        for(File file:files){
            if(file.isFile())
                //如果是文件累加
                len+=file.length();
            else
                //如果是文件夹,递归
                len+=getlen(file);
        }
        return len;
    }
}

统计每种文件的个数

考虑子文件夹

File 递归 Map集合

写一个方法

参数是要统计的那个文件夹

返回值是用来统计map集合的

键：后缀名

值：出现次数

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        File file=new File("D:\\新建文件夹");
        HashMap<String,Integer>hm=getCount(file);
        System.out.println(hm);
    }
    public static HashMap<String,Integer> getCount(File src){

        HashMap<String,Integer>hm=new HashMap<>();
        //定义集合来统计

        File[] files=src.listFiles();
        //进入文件夹src

        for(File file:files){
            //如果是文件，进行统计
            if(file.isFile()){
                String name=file.getName();
                String arr[]=name.split("\\.");
                if(arr.length>=2){
                    String endName=arr[arr.length-1];
                    if(hm.containsKey(endName)){
                        //存在
                        int count=hm.get(endName);//把值拿出来
                        count++;//自增
                        hm.put(endName,count);//再放回去
                    }
                    else {
                        //第一次出现
                        hm.put(endName,1);
                    }
                }
            }
            else {
                //如果是文件夹，进行递归 自己调用自己
                HashMap<String,Integer>sonMap=getCount(file);
                //sonMap是子文件夹中每一种文件的个数
                //遍历sonMap把里面的数值都累加到hm当中
                Set<Map.Entry<String,Integer>>entries=sonMap.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    //获取键值对对象
                    String key=entry.getKey();
                    int value=entry.getValue();
                    if(hm.containsKey(key)){
                        //存在
                        int count=hm.get(key);//count是从hm获取出来的数值
                        count+=value;//value是从sonMap中获取出来的值
                        hm.put(key,count);//放进去，覆盖
                    }
                    else{
                        //不存在
                        hm.put(key,value);
                    }
                }
            }
        }
        return hm;
    }
}

个人号推广

博客主页

多多!-CSDN博客

Web后端开发

https://blog.csdn.net/qq_30500575/category_12624592.html?spm=1001.2014.3001.5482

Web前端开发

https://blog.csdn.net/qq_30500575/category_12642989.html?spm=1001.2014.3001.5482

数据库开发

https://blog.csdn.net/qq_30500575/category_12651993.html?spm=1001.2014.3001.5482

项目实战

https://blog.csdn.net/qq_30500575/category_12699801.html?spm=1001.2014.3001.5482

算法与数据结构

https://blog.csdn.net/qq_30500575/category_12630954.html?spm=1001.2014.3001.5482

计算机基础

https://blog.csdn.net/qq_30500575/category_12701605.html?spm=1001.2014.3001.5482

回忆录

https://blog.csdn.net/qq_30500575/category_12620276.html?spm=1001.2014.3001.5482

 

多多!
关注
  • 42
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
Java语言与面向对象的程序设计
张睿的博客
08-29 4632
这几天很迷茫，听老师介绍了一款软件~中国大学MOOC。刚好我是软件专业的学生，索性听了北京大学老师的一节关于Java的讲课，果断被震撼到了，他们的讲课给人一种很深刻(深入)的感觉。我今天就把老师讲到的东西记了下来，以便于有兴趣的朋友阅读… Java分为三大平台 Java SE 标准版 Java EE 企业版 Java ME 微型版 Java的开发工具包 JDK（J...
JavaSE基础(114) File对象的创建以及创建文件和文件夹
热门推荐
郑清
09-06 3万+
File:抽象的描述了磁盘路径(创建一个具体的对象==>指定路径 但是该路径的文件或者文件夹不一定在磁盘真的存在!!!) 一个File对象就是一个具体的文件或者目录（目的：指定文件或文件夹保存的路径）如何得到一个具体的File对象？？ ==》通过构造方法 File(String pathname):通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。...
JavaSE核心技术——面向对象编程基础练习题
qq_37067955的博客
08-17 1万+
1、定义一个点类Point，包含2个成员变量x、y分别表示x和y坐标，2个构造器Point()和Point(intx0,y0),以及一个movePoint（int dx,int dy）方法实现点的位置移动，创建两个Point对象p1、p2，分别调用movePoint方法后，打印p1和p2的坐标。[必作题] Point 类代码： public class Point { int x; ...
JavaSE 基础习题整理 - 面向对象篇
坐看云起时_雨宣
03-11 8364
大家好，今天空闲时间整理了一份JavaSE面向对象的常用习题，喜欢的朋友可以关注我。习题来自互联网，不喜勿喷 1、定义长方形类，含： 属性：宽、高（整型）； 方法：求周长、面积； 构造方法3个：（1）无参——宽、高默认值为1；（2）1个参数——宽、高均为参数值；（3）2个参数——宽、高各为参数值。 2、定义圆类，它有一个变量radius(半径)。从键盘输入数据，通过构造方法传递给...
04【面向对象、封装、static】
緑水長流*z
07-30 5986
一、面向对象 1.1 面向对象概述 1.1.1 什么是对象 在Java中，对象（Object）是指一个具体事物的实例，任何事物都可以使用对象（类）来描述，如猫、狗、计算机、杯子、云、水、空气、叶子、灰尘等看得见的、看不见的、宏观的、微观的、具体的、抽象的都是对象，总之"万物皆对象"； 1.1.2 面向对象程序设计 我们前面就提到过，Java是一门面向对象的编程语言，面向对象是一种程序设计思想，与之对应的还有面向过程程序设计；面向对象是把一个对象的特征（属性）和行为单独封装到对象
【JavaSE练习】面向对象_模拟银行账户
love__nana
07-04 1万+
import java.util.Scanner; /* * 编写程序，模拟银行账户功能。要求如下： * 属性：账号、储户姓名、地址、存款余额、最小余额 * 方法：存款、取款、查询。根据用户操作显示储户相关信息 * 如：存款操作后，显示储户原有余额、今日存款数额及最终存款余额 * 取款时，若最后余额小于最小余额，拒绝收款，并显示“至少保留余额XXX” */ //账户类 class
JavaSE 面向对象基础
苦瓜的博客
11-06 2890
JavaSE类和对象对象内存图成员变量和局部变量封装构造方法 类和对象 对象内存图 成员变量和局部变量 封装 构造方法
Java面向对象编程，绘制思维导图（全面详细整理）
Java智慧阁
11-01 3760
面向对象编程 前言：整合之前内容，面向对象三部曲的文章。《上》《中》《下》。 按照知识内容，绘制形成思维导图，详细记录了各个模块。 欢迎大家积极讨论！若有遗漏点或者错误点，烦请指出<抱拳>。 大体框架图 点击图片，右键，在新标签页中打开图片，点击即可放大。 展开分支 2、类（class） 整体结构图： 所有分支图示1： 所有分支图示2： 3、面向对象的三大特征 整体结构图： 4、面向对象关键字 整体结构图： 所有分支图示1： 所有分支图示2： 后面略，详细内容见 《面向对象编程
面向对象程序设计：JavaSE-任务81
08-08
面向对象程序设计：JavaSE-任务81
面向对象程序设计：JavaSE-任务101
08-08
面向对象程序设计：JavaSE-任务101
面向对象程序设计：JavaSE-任务11
08-08
面向对象程序设计：JavaSE-任务11
面向对象程序设计：JavaSE-任务21
08-08
面向对象程序设计：JavaSE-任务21
面向对象程序设计：JavaSE-任务41
08-08
（2）设计实现画板类，在画板类的main方法中①画一个圆形（即创建一个圆形对象，并给其成员属性赋值），然后调用方法获取它的面积和周长并打印 （1）定义时间类（类
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 305
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 523
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 595
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 396
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
javase之面向对象
09-07
面向对象是一种编程范式，它将程序设计看作是对象之间的交互。在Java语言中，面向对象编程是一种重要的编程方式。引用中提到了面向对象的特征，包括抽象、封装、继承和多态。抽象指的是将具体的事物抽象成类，类是对象的抽象描述。封装指的是将数据和对数据的操作封装在一起，通过对象的方法来访问数据。继承指的是一个类可以继承另一个类的属性和方法，从而实现代码的复用。多态指的是同一种方法可以具有不同的实现方式，通过方法的重写和重载来实现多态性。引用中提到了类是对象的抽象，而对象是类的实例。例如，一个人可以被看作是人这个类的一个具体对象。引用中还提到了在Java中，所有没有继承的类都会默认继承Java的Object类，所以Java中的所有类都是Object类的子类。综上所述，面向对象是JavaSE中的一个重要概念，它通过类和对象的抽象、封装、继承和多态来实现程序的设计和开发。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值