1
2

"C:\VScode\MainProject_rewrite\image\about_img.png"
"C:\VScode\logindownload\image\bg.jpg"

1
2

"MainProject_rewrite\image\about_img.png"
"logindownload\image\bg.jpg"

1
2
3
4
5

File file = new File(“pathname”);
  
    String str = "C:\\JavaStudy\\a.txt";
    File f1 = new File(str);
    System.out.println(f1);

1
2
3
4
5
6
7
8

File(String parent, String child);

    String parent = "C:\\JavaStudy";
    String child = "a.txt";
    File f2 = new File(parent, child);

    // 等价于自己拼接（不推荐）
    File f3 = new File(parent + "\\" + child);

1
2
3
4
5

File(File parent, String child);

    File parent = new File("C:\\JavaStudy");
    String child = "a.txt";
    File f3 = new File(parent, child);

1

File(URI uri);

1
2
3
4
5
6
7

import java.io.File;
public class TestFileSeparator {
    public static void main(String[] args) {
        System.out.println("Windows系统中的pathSeparator值为：" + File.pathSeparator);
        System.out.println("Windows系统中的separator值为：" + File.separator);
    }
}

 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

File f1 = new File("C:\\JavaStudy\\HelloWorld.java");
File f2 = new File("C:\\JavaStudy");
File f3 = new File("MyProjcet\\src");


System.out.println("f1是否为文件夹： " + f1.isDirectory());
System.out.println("f2是否为文件夹：" + f2.isDirectory());
System.out.println("f1是否为文件：" + f1.isFile());
System.out.println("f1是否存在：" + f1.exists());


// length() 方法返回文件大小
long a = f1.length();
System.out.println("f1的大小：" + a);
// 使用文件夹调用 length() 方法，不同操作系统返回的值不一样，但都是不对的
System.out.println("f2的大小：" + f2.length());


// getAbsoluteFile() 返回绝对路径
System.out.println("f1的绝对路径：" + f1.getAbsoluteFile());
System.out.println("f2的绝对路径：" + f2.getAbsoluteFile());
System.out.println("f3的绝对路径：" + f3.getAbsoluteFile());


// getPath() 方法返回定义时的路径
System.out.println("f1的定义时路径：" + f1.getPath());
System.out.println("f3的定义时路径：" + f3.getPath());


// 文件返回文件名+后缀，文件夹返回文件夹名
String str1 =  f1.getName();
String str2 =  f2.getName();
System.out.println("f1的名字：" + str1);
System.out.println("f2的名字：" + str2);


// lastModified() 方法返回最后修改时间（时间毫秒值）
long b = f1.lastModified();
System.out.println("f1的最后修改时间：" + b);
// 把毫秒值变为字符串表示的时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date date = new Date(f1.lastModified());
System.out.println(sdf.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
26
27
28
29
30
31
32
33
34

File f1 = new File("C:\\JavaStudy\\createNewFile.txt");
boolean a = f1.createNewFile();
System.out.println("创建文件：" + a);
boolean b = f1.createNewFile();
// 1.若不存在，创建成功，返回true；若已存在，创建失败，返回false
System.out.println("重复创建文件：" + b);
// 2.尝试在不存在的父级目录下新建文件，出现异常IOException
File f2 = new File("C:\\JavaStudy\\test\\createNewFile.txt");
// 3.如果不写后缀名，则会创建一个没有后缀的文件
File f3 = new File("C:\\JavaStudy\\createNewFile");
boolean c = f3.createNewFile();
System.out.println("创建没有后缀的文件：" + c);


// 路径不能重复
File f4 = new File("C:\\JavaStudy\\createNewFile");
boolean d = f4.mkdir();
System.out.println("创建路径相同的文件夹：" + d);
// 只能创建单级文件夹
File f5 = new File("C:\\JavaStudy\\test");
boolean e = f5.mkdir();
System.out.println("创建文件夹：" + e);


// mkdirs() 方法可以创建单级文件夹，也可以创建多级文件夹
File f6 = new File("C:\\JavaStudy\\test\\oth");
boolean f = f6.mkdirs();
System.out.println("创建多级文件夹：" + f);


// 1.如果删除的是文件，直接删除
// 2.如果删除的是文件夹，空文件夹直接删除，非空文件夹删除失败
boolean g = f6.delete();
System.out.println("删除文件或文件夹：" + g);

1
2
3
4
5
6

File f1 = new File("C:\\JavaStudy");
File[] files = f1.listFiles();
for (File file : files) {
    // file 依次表示 JavaStudy 文件夹中的每一个文件
    System.out.println(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
56
57
58
59
60
61
62
63
64
65

// 获取系统中所有盘符
File[] arr = File.listRoots();
System.out.println("系统盘符："+Arrays.toString(arr));


// 获取当前路径下所有内容，仅能获取名字
File f1 = new File("C:\\JavaStudy");
String[] list = f1.list();
String str = "";
for (String s : list) {
    if (str != ""){
        str = str + ", " + s;
    }else str = s;
}
System.out.println("获取当前路径下所有内容为：" + "["+str+"]");


// 利用文件名过滤器获取当前目录下所有内容
// 例：获取当前目录下所有 txt 文件
String[] arr1 = f1.list(new FilenameFilter() {	// 匿名内部类
    @Override
    public boolean accept(File dir, String name) {
        // 拼接父级路径和子级路径
        File src = new File(dir,name);
        // 如果返回值为true，则表示当前路径保留；否则舍弃
        return src.isFile() && name.endsWith(".txt");
    }
});
System.out.println("前目录下所有 txt 文件：" + Arrays.toString(arr1));


// 通过 f1.listFiles() 获取所有内容再根据后缀获取 txt 文件
File[] files = f1.listFiles();
System.out.println("当前目录下所有内容：" + Arrays.toString(files));
System.out.print("当前目录下txt文件：");
for (File file : files) {
    if (file.isFile() && file.getName().endsWith(".txt")) {
        System.out.println(file);
    }
}


// public File[] listFiles(FileFilter filter)
File[] arr2 = f1.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        // return true;
        return pathname.isFile() && pathname.getName().endsWith(".txt");
    }
});
System.out.println
        ("listFiles(FileFilter filter)方法返回txt文件：" + Arrays.toString(arr2));


// public File[ ] listFiles(FilenameFilter filter)
File[] arr3 = f1.listFiles(new FilenameFilter() {
    @Override
    // 与 listFiles(FileFilter filter) 不同之处在于返回的是父级路径和子级路径
    public boolean accept(File dir, String name) {
        File src = new File(dir,name);
        return src.isFile() && name.endsWith(".txt");
    }
});
System.out.println
        ("listFiles(FilenameFilter filter)方法返回txt文件：" + Arrays.toString(arr3));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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

public class Test1 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("aaa");
        if(!f1.exists()){
            f1.mkdirs();
        }
        File f2 = new File(f1,"a.txt");
        f2.createNewFile();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        File file = new File("C:\\JavaStudy");
        System.out.println(haveMp4(file));
    }
    
    public static boolean haveMp4(File file) {
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile() && f.getName().endsWith(".mp4")) {
                // System.out.println(f.getName());
                return true;
            }
        }
        return false;
    }
}

 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

import java.io.File;

public class Test3 {
    public static void main(String[] args) {
        findMp4();
    }

    public static void findMp4(File f1){
        File[] files = f1.listFiles();
        // files 不为 null（能够访问盘符或文件夹）
        if (files != null){
            for (File file : files) {
                if (file.isFile()){
                    // 如果是文件，再判断后缀
                    if (file.getName().endsWith(".mp4")){
                        System.out.println(file);
                    }
                }else {
                    // 不是文件，则一定是文件夹，递归
                    findMp4(file);
                }
            }
        }
    }

    public static void findMp4(){
        File[] arr = File.listRoots();
        for (File f : arr) {
            findMp4(f);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import java.io.File;

public class Test4 {
    public static void main(String[] args) {
        File f1 = new File("aaa");
        deleteFile(f1);
    }

    public static void deleteFile(File f1){
        File[] files = f1.listFiles();
        for (File file : files) {
            if (file.isFile()){
                file.delete();
            }else {
                // 递归
                deleteFile(file);
            }
        }
        // 最后删除自己
        f1.delete();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import java.io.File;

public class Test5 {
    public static void main(String[] args) {
        File f1 = new File("C:\\JavaStudy");
        System.out.println(getSize(f1));
    }

    public static long getSize(File f1){
        long size = 0;
        File[] files = f1.listFiles();
        for (File file : files) {
            if (file.isFile()){
                size += file.length();
            }else {
                // 需要定义全局变量，否则递归时重新定义局部变量
                // 在递归时带上 size
                size += getSize(file);
            }
        }
        return size;
    }
}

 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

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

public class Test6 {
    public static void main(String[] args) {
        /*
            需求：统计文件夹内每种文件的个数并打印。（考虑子文件夹）
            输出：txt：3个   doc：4个   jpg：6个
            涉及知识：File  递归  Map集合
         */
        File f1 = new File("C:\\JavaStudy");
        HashMap<String, Integer> m1 = getCount(f1);

        Set<Map.Entry<String, Integer>> entries = m1.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + "：" + value + "个");
        }
    }

    public static HashMap<String, Integer> getCount(File f1) {
        HashMap<String, Integer> m1 = new HashMap<>();
        File[] files = f1.listFiles();
        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 (m1.containsKey(endName)) {
                        int count = m1.get(endName);
                        count++;
                        m1.put(endName, count);
                    } else {
                        m1.put(endName, 1);}
                }
            } else {
                HashMap<String, Integer> m2 = getCount(file);
                Set<Map.Entry<String, Integer>> entries = m2.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    String key = entry.getKey();
                    int value = entry.getValue();
                    if (m1.containsKey(key)) {
                        int count = m1.get(key);
                        count += value;
                        m1.put(key, count);
                    } else {
                        m1.put(key, value);
                    }
                }
            }
        }
        return m1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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

public class Test7 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src\\a.txt");
        if (!f1.exists()){
            f1.createNewFile();
        }

        // 创建对象
        FileOutputStream fos1 = new FileOutputStream("src\\a.txt");
        // FileOutputStream fos1 = new FileOutputStream(new File("src\\a.txt"));
        // 写出数据
        fos1.write(65);
        // 释放资源
        fos1.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import java.io.FileOutputStream;
import java.io.IOException;

public class Test8 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\a.txt");
        fos.write(65);  // A

        byte[] bytes = {66, 67, 68, 69, 70};    // B C D E F
        fos.write(bytes);

        // void write (byte[] b, int off, int len)
        // off 表示开始位置，len 表示字节个数
        fos.write(bytes, 1, 2);

        fos.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Test9 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\a.txt");
        String str1 = "Hello World";
        // 每个操作系统换行符不一样
        // windows： \r\n
        // linux：   \n
        // macos：   \r
        // 在 windows 系统中，java 对回车换行进行了优化，只要写一个就行
        String str2 = "\r\n";
        byte[] bytes1 = str1.getBytes();
        byte[] bytes2 = str2.getBytes();
        System.out.println(Arrays.toString(bytes1));
        fos.write(bytes1);
        fos.write(bytes2);
        fos.write(bytes1);
        fos.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// FileOutputStream 后还可以传递一个参数，默认为 false，当值为 true 表示可以续写
public FileOutputStream(String name) throws FileNotFoundException {
    this(name != null ? new File(name) : null, false);
}

FileOutputStream fos = new FileOutputStream("src\\a.txt", true);
...
if (f1.getName().endsWith(".txt") && f1.length() != 0){
    fos.write(bytes2);
    fos.write(bytes1);
}else {
    fos.write(bytes1);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import java.io.FileInputStream;
import java.io.IOException;

public class Test10 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\a.txt");
        int a = fis.read();
        System.out.println((char) a);
        int b = fis.read();
        System.out.println((char) b);
        // 当 read() 方法无法获取文件中的数据时，返回 -1
        fis.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import java.io.FileInputStream;
import java.io.IOException;

public class Test11 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\a.txt");
        int a;
        while ((a = fis.read()) != -1){
            System.out.print((char) a);
        }
        fis.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test12 {
    public static void main(String[] args) throws IOException {
        // 读数据
        FileInputStream fis = new FileInputStream("src\\note.pdf");
        // 写数据
        FileOutputStream fos = new FileOutputStream("out\\copy.pdf");
        int a;
        while ((a = fis.read()) != -1) {
            fos.write(a);
        }
        // 释放资源规则：先开的流最后再关闭
        fos.close();
        fis.close();
    }
}

 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

import java.io.FileInputStream;
import java.io.IOException;

public class Test13 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\a.txt");
        byte[] bytes = new byte[5];
        // 返回 int 类型的数据，代表本次读取到了多少个数据
        // 同时将读取到的数据存储到 bytes 数组中
        int num = fis.read(bytes);
        System.out.println(num);
        // 将数组里面所有的数据变成字符串并打印输出，bytes 中存储 "Hello"
        // 打印 "Hello"
        String str = new String(bytes);
        System.out.println(str);

        // 第二次遍历 Hello World，bytes 中存储 " Worl"
        // 打印 " Worl"
        int num2 = fis.read(bytes);
        System.out.println(num2);
        String str2 = new String(bytes);
        System.out.println(str2);

        // 第三次遍历 Hello World，bytes 中存储 "dWorl"
        // 添加起始位置 0 索引和打印个数 num3，打印 "d"
        int num3 = fis.read(bytes);
        System.out.println(num3);
        String str3 = new String(bytes, 0, num3);
        System.out.println(str3);

        fis.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test14 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\note.pdf");
        FileOutputStream fos = new FileOutputStream("out\\copy.pdf");
        byte[] bytes = new byte[1024 * 1024 * 5];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        fos.close();
        fis.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import java.io.FileInputStream;
import java.io.IOException;

public class Test15 {
    public static void main(String[] args) throws IOException {
        // b.txt 文件内容为 "你好。"
        FileInputStream fis = new FileInputStream("src\\b.txt");
        int a;
        while ((a = fis.read()) != -1){
            System.out.print((char) a);
        }
        // 输出 "你好ã ,"
    }
}

 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

package com.company.io;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Test16 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        /*
            Java中编码的方法
                public byte[] getBytes()                         	使用默认方式进行编码
                public byte[] getBytes(stringI charsetName)         使用指定方式进行编码
            Java中解码的方法
                string(byte[] bytes)                                使用默认方式进行解码
                String(byte[] bytes, string charsetName)            使用指定方式进行解码
        */
        
        // 编码
        String str = "Hello你好";
        byte[] bytes = str.getBytes();	// 编码后的字节数据，在存储时再以二进制的形式存储
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str.getBytes("GBK");
        System.out.println(Arrays.toString(gbks));
        
        // 解码
        String trans1 = new String(bytes);
        System.out.println(trans1);

        String trans2 = new String(bytes, "GBK");   // 尝试用GKB解码，出现乱码
        System.out.println(trans2);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package com.company.io;

import java.io.FileReader;
import java.io.IOException;

public class Test17 {
    public static void main(String[] args) throws IOException {
        // 创建对象
        FileReader fr = new FileReader("src\\c.txt");

        // 定义变量存储fr.read()的返回值避免重复调用导致跳读
        int ch;
        while ((ch = fr.read()) != -1){
            // 使用强制类型转换输出字符类型
            System.out.println((char) ch);
        }

        // 释放资源
        fr.close();
    }
}

 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

package com.company.io;

import java.io.FileReader;
import java.io.IOException;

public class Test17 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("src\\c.txt");

        //        int ch;
        //        while ((ch = fr.read()) != -1){
        //            System.out.println((char) ch);
        //        }
        
        // 字节流 byte 字符流 char
        char[] chars = new char[2];
        int len;
        // 读取数据，解码，强转三步合并了，把强转之后的字符放到了数组当中
        // 空参read方法 + 强制类型转换
        while ((len = fr.read(chars)) != -1) {
            // 转换为字符串，输出每次chars数组里的元素
            System.out.println(new String(chars, 0, len));
        //            for (char aChar : chars) {
        //                System.out.print(aChar);
        //            }
        }

        fr.close();
    }
}

 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

package com.company.io;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;

public class Test18 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\a.txt");
        fos.write(25105);
        fos.close();

        FileWriter fw = new FileWriter("src\\b.txt", true);
        // 根据字符集的编码方式进行编码，把编码后的数据写到文件中
        // IDEA 默认使用 UTF-8 进行编码
        fw.write(25105);

        // 使用 str 字符串写出
        String str = "\r\n今天天气真不错。";
        fw.write(str);

        //使用 char 数组写出
        char chars[] = {'\r', '\n', 'h', 'i', '你', '好'};
        fw.write(chars);

        fw.close();
    }
}

1
2
3
4
5
6
7
8

File file = new File(“pathname”);
public boolean isFile()
public boolean exists()
public long length()
public String getName()
public boolean createNewFile()
public boolean mkdirs()
public File[] listFiles()

1
2
3
4

FileOutputStream fos = new FileOutputStream(“pathname”);
FileInputStream fis = new FileInputStream(“pathname”);
void write(byte[] b, int off, int len)
public int read(byte[] buffer)