软件信息网 移动端开发  File的成员方法有很多,但是只有一部分需要注意:【创建/遍历/获取】

 File的成员方法有很多,但是只有一部分需要注意:【创建/遍历/获取】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com.Lucky.File;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * File的成员方法【常用】:
 *              1.isDirectory()   判断是否为文件夹
 *              2.isFile()        判断是否是文件
 *              3.exists()        判断是否不存在
 *              4.getName()        获取文件名称【如果是文件就返回文件名+文件后缀】【如果是文件夹就返回文件名】
 *              5.getAbsolutePath() 获取文件的绝对路径
 *              6.getPath()         获取定义文件的路径【获取new File()这里的路径】
 *              7.length()          获取文件的大小【单位是字节,注意:不能获取文件夹的大小】
 *              8.lastModified       获取文件最后被修改的毫秒值
 *
 *
 * 接下来的是:  File的创建以及删除方法:看FileMothods1
 */
public class FileMothods {
    public static void main(String[] args) {
        String str="C:\\Users\\Lucky\\Desktop\\测试文件夹";
        String child="cs.txt";
        System.out.println("----File(String str)   把字符串的路径信息转换成File对象----");
        File file1=new File(str);
        System.out.println(file1);
        System.out.println("------------------------成员方法---------------------------");
        System.out.println(file1.isDirectory());
        System.out.println(file1.isFile());
        System.out.println(file1.exists());
        System.out.println();
        File val=new File("H:\\项目\\javaSE\\IO\\src\\com\\Lucky\\File\\test");
        System.out.println(val.getName());
        System.out.println(val.getAbsolutePath());
        System.out.println(val.getPath());
        System.out.println(val.lastModified());  //获取文件最后被修改的毫秒值
        ///拓展:  将该时间的毫秒值转化成格式为 :  yyyy年MM月dd日
       long nb= val.lastModified();
        Date date =new Date(nb);
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy年MM月dd日");
        System.out.println(dateFormat.format(date));
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.Lucky.File;
import java.io.File;
/**
 * File对象之创建/删除方法
 *        1.createNewFile         创建一个新的文件
 *         【注意点:①创建的一定是文件②原来不存在返回true,否则false③如果父级路径不存在,会报IO异常】
 *        2.mkdir                 创建一个新的文件夹
 *         【注意点:①创建的文件夹路径是唯一的②创建单个文件夹】
 *        3.mkdirs                 创建一个/多个新的文件夹
 *          【注意点:①创建的文件夹路径是唯一的②创建一个/多个新的文件夹】
 *        4.delete                 删除文件【或空文件夹】
 */
public class FileMothods1 {
    public static void main(String[] args) {
        File val=new File("H:\\项目\\javaSE\\IO\\src\\com\\Lucky\\File\\test");
        boolean delete = val.delete();
        /*只能删除文件【或空文件夹】*/
        System.out.println(delete);
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package com.Lucky.File;
import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
/**
 * File的遍历: listFiles()       获取当前路径下的所有内容
 */
/*
当调用者File表示的路径不存在时,返回null
当调用者File表示的路径是文件时,返回null
当调用者File表示的路径是一个空文件夹时,返回一个长度为0的数组
当调用者File表示的路径是一个有内容的文件夹时,将里面所有文件和文件夹的路径放在File数组中返回
当调用者File表示的路径是一个有隐藏文件的文件夹时,将里面所有文件和文件夹的路径放在File数组中返回,包含
当调用者File表示的路径是需要权限才能访问的文件夹时,返回null件
 */
public class FileMothods2 {
    public static void main(String[] args) {
        File file=new File("H:\\YunGameDownload\\leidian\\data");
        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);
        }
    /////////////////////////////////////////////////////////////////////////
        System.out.println("----了解即可----");
        System.out.println("list");
        File file1=new File("H:\\YunGameDownload\\leidian\\data");
        String[] list = file1.list();
        System.out.println("获取当前路径下的所有内容【仅仅是名称】"+list);  //返回的是数组
        //new FilenameFilter()文件过滤器
        String[] list1 = file1.list(new FilenameFilter() {
            /*
              dir: 表示父级路径
              name: 表示子级路径
              return:  true代表保留,反之代表舍弃
             */
            @Override
            public boolean accept(File dir, String name) {
                //过滤要求:是文件并且文件后缀是.txt
                File file2 = new File(dir, name);
                return file2.isFile() && file2.getName().endsWith(".txt");
            }
        });
        System.out.println(Arrays.toString(list1)+"\n");
        System.out.println("listRoots");
        File[] files1 = File.listRoots();
        System.out.println(files1);
    }
}

  File的综合小练习:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package com.Lucky.File;
import java.io.File;
/*
练习1要求:  查询所有盘符下的.jpg文件【存在Bug】
练习2要求:  删除指定目录的所有内容【不操作,我怕删除掉我的小电影】
      注意点:{
                 步骤:先进入文件夹,遍历文件夹,再判断文件夹里面的每一个内容
                      如果“文件夹里面的内容”是文件就直接delete
                      如果“文件夹里面的内容”又是一个文件夹,就再次调用【利用递归】
                       -->最后√如果是空文件夹就直接delete
      }
 */
public class test {
    public static void main(String[] args) {
        findAll();
    }
    public static void findAll(){
        //获取全部盘符
        File[] files = File.listRoots();
        for (File file : files) {  // file== C D E F G
//            String string = file.toString();
//            string =string+"\\";
//            File valFile=new File(string);
            findALL(file);
        }
    }
    /**
     * 单个盘符的所有jpg文件
     * @param file
     */
    public static void findALL(File file){
      File file1=new File("file");
          //1.进入文件夹
          File[] files = file1.listFiles();
          //2.遍历
        if(files!=null){
          for (File FI : files) {
              //3.判断[也是递归终止的条件]
              if(FI.isFile()){
                  System.out.println(FI.getName().endsWith(".jpg"));
              }else {
                  //不是文件,就重复调用该方法【递归】
                  findALL(FI);
              }
          }
      }
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.Lucky.File;
import java.io.File;
/*
练习3要求:查询指定路径下的总大小
 */
public class test1 {
    public static void main(String[] args) {
        File file=new File("H:\\YunGameDownload\\leidian\\data");
        System.out.println(findCount(file));  //单位是字节
    }
   public static long findCount(File file){
        long len=0;   //总大小
        //打开文件夹
       File[] files = file.listFiles();
       for (File file1 : files) {
            //判断是否是文件夹
           if(file1.isFile()){
               long val=file1.length();
               len+=val;
           }else {
               //不是文件【证明这是文件夹{使用递归}】
               /*
               注意点: 调用递归之后,递归里面的变量值不会累加【len是局部变量】
                */
               //解决方法:
              len+=findCount(file1);
           }
       }
     return len;
   }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package com.Lucky.File;
/*
  练习3:统计指定路径下每种类型的文件数量
   */
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
 * 分析: 要用到 -->  Map集合  递归  File
 */
public class test2 {
    public static void main(String[] args) {
        File fi=new File("H:\\YunGameDownload\\leidian");
         //调用方法
        HashMap<String, Integer> map = anyFileCount(fi);
        Set<String> strings = map.keySet();
        for (String string : strings) {
            //获取值
            Integer integer = map.get(string);
            System.out.println(string+":"+integer);
        }
    }
    public static HashMap<String,Integer> anyFileCount(File file){
        //1.定义Map集合
        HashMap<String,Integer> map=new HashMap<>();
        //2.进入文件夹
        File[] files = file.listFiles();
        //3.遍历
        for (File file1 : files) {
            //4.判断是不是文件。
            if(file1.isFile()){
               // 5.是文件获取文件名【文件名包括后缀】
                String fileName = file1.getName();
                String[] splitName = fileName.split("\\.");//这个符号要进行转义
                //6.判断splitName的长度是否>=2【排除那些没有后缀的文件】
                if(splitName.length>=2){
                    //7.获取后缀
                   int Intval= splitName.length-1;
                   String val=splitName[Intval];
                    //8.判断map集合中是否存在该后缀
                    if(map.containsKey(val)){
                         //9.存在就获取map集合中该键的值【数量】
                        Integer integer = map.get(val);
                        integer++;
                        //10.将添加的数量添加到map集合中
                        map.put(val,integer);
                    }else {
                        //不存在就直接添加数据
                        map.put(val,1);
                    }
                }
            }else {
                //不是文件【就是文件夹】使用递归
                /*
                 注意点:将递归的数据也要添加到map集合中
                 */
                HashMap<String,Integer> chileCount=anyFileCount(file1);
                //遍历chileCount集合
                Set<Map.Entry<String, Integer>> entries = chileCount.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    String key = entry.getKey();
                    int val = entry.getValue();
                    //判断map集合中是否存在该后缀
                    if(map.containsKey(key)){
                        //9.存在就获取map集合中该键的值【数量】
                        Integer integer = map.get(key);
                        integer=integer+val;
                        //10.将添加的数量添加到map集合中
                        map.put(key,integer);
                    }else {
                        //不存在就直接添加chileCount集合的数据
                        map.put(key,val);
                    }
                }
            }
        }
        //11.返回集合
         return map;
    }
}

  拓展:File的构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.Lucky.File;
import java.io.File;
/**
 * File类的构造器方法讲解:
 *
 *           File(String str)   把字符串的路径信息转换成File对象
 *           File(String parent,String Child) 将父级路径字符串与子路径字符串拼接成File对象
 *           File(File parent,String Child)   将父级路径与子路径字符串拼接成File对象
 *
 *    每天一个小知识:
 *            File对象可以表示为文件/路径/文件夹【可以允许File不存在】
 *            绝对路径是指带有盘符的路径信息
 *            相对路径是根据当前项目找的路径
 */
public class flieConstructor {
    public static void main(String[] args) {
        String str="C:\\Users\\Lucky\\Desktop\\测试文件夹";  //不存在的
        String child="cs.txt";  //不存在的
        System.out.println("----File(String str)   把字符串的路径信息转换成File对象----");
        File file1=new File(str);
        System.out.println(file1);
        System.out.println("----File(String parent,String Child) 将父级路径字符串与子路径字符串拼接成File对象----");
        File file2=new File(str,child);
        System.out.println(file2);
        System.out.println("----File(File parent,String Child) 将父级路径与子路径字符串拼接成File对象----");
        File file3=new File(file1,child);
        System.out.println(file3);
    }
}

 

本文来自网络,不代表软件信息网立场,转载请注明出处。软件定制开发交流:15528175269(微信同号)https://www.saasyo.com/xz/15852.html

作者: 王鹏程序员

上一篇
下一篇
联系我们

联系我们

15889726201

在线咨询: QQ交谈

邮箱: 187395037@qq.com

工作时间:周一至周五,9:00-17:30,节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

关注微博
返回顶部