API-Day09——File-文件类、路径、IO流

最新推荐文章于 2024-08-23 15:54:50 发布

WinWinWinooo

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量171

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_43852153/article/details/107719643

版权

java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1.File - 文件类, 可以表示文件或者目录

构造方法

方法一： new File(String 文件路径)

 // 传入文件路径, 构造File对象
        // 注意: new 出来的File对象, 只是在JVM内存中有一个对象而已
        //      和本地磁盘有没有这个文件, 无关 !
        File file = new File("a.txt");
        System.out.println(file);

方法二： new File(String 父路径, String 子路径)

 // 传入文件父路径 和 子路径, 共同构造File对象
        File file = new File("b/c","d/a.txt");
        System.out.println(file); // b/c/d/a.txt

常用API

String path = file.getAbsolutePath() :获得文件/目录的绝对路径。

File file = new File("a.txt");

        // 获得file的绝对路径
        String path = file.getAbsolutePath();
        // /Users/bonnie/IdeaWorks/corejava/API_day09/a.txt
        System.out.println(path);

boolean exists = file.exists() :file对应的文件或者目录存不存在。

 File file = new File("src");
        // file对应的文件或者目录存不存在
        boolean exists = file.exists();
        System.out.println("src 存不存在:" + exists);
    }

file.isDirectory():返回值类型boolean，file是不是目录。
file.isFile():返回值类型boolean，file是不是文件。

File file = new File("src"); // 目录, 并且存在
       File file1 = new File("c.txt"); // 文件, 并且存在
       File file2 = new File("a.txt"); // 不存在

       System.out.println("src是目录吗? " + file.isDirectory());
       System.out.println("src是文件吗? " + file.isFile());
       System.out.println("c是目录吗? " + file1.isDirectory());
       System.out.println("c是文件吗? " + file1.isFile());

       System.out.println("a是目录吗? " + file2.isDirectory());
       System.out.println("a是文件吗? " + file2.isFile());

file.creatNewFile ：创建文件。

// 创建一个文件
        File file2 = new File("a.txt");
        // file2.exists() 返回true, 就表示存在, 就不能创建新文件
        // 如果文件不存在, 就创建这个文件
        // 如果文件存在, 就不创建, 也不会报错
        file2.createNewFile();

创建目录方法1：file.mkdir();

  File file2 = new File("dir");
        // 创建目录
        file2.mkdir();

创建目录方法2：file.mkdirs()；
与方法一的不同点：可以将不存在的父目录一起创建。

File file2 = new File("test/a/b");
        // 创建目录, 并且将不存在的父目录一起创建
        file2.mkdirs();

文件的删除：删除非空目录的递归方法

 public void deleteFile(File file) {
        // 结束递归的条件: 1.file对象本身就是文件. 2.file是一个空目录
        File[] files = file.listFiles();
        if (files != null) {
            for (File f : files) {
                deleteFile(f);
            }
        }
        file.delete();
    }
    @Test
    public void test01() {
        File file = new File("test");
        deleteFile(file);
    }

如下代码中：test02中new的file为.text时因为文件已经打开到底无法继续打开下一层，所以files为空；test03中（dir/b/a.text）new的file还有下一层所以不为空，length为1；

 @Test
    public void test02() {
        // file 普通文件
        File file = new File("a.txt");
        File[] files = file.listFiles();
        System.out.println(files); // null
    }
    @Test
    public void test03() {
        // file 空白目录
        File file = new File("dir/b");
        File[] files = file.listFiles();
        System.out.println(files.length);
    }

筛选器的模式：
例如：获得file对象中所有的文件 listFiles()
File file = new File(".");//当前目录
file.listFiles(new FileFilter() {
@Override
public boolean accept(File f) {
// 处理了f, 让他返回true, 表示f要保留
// 处理了f, 返回false, 表示f不想保留了
return false;
}
});
// filter.accept(f) --> 返回true

筛选器方法： public File[] listFiles(FileFilter filter) {
// 得到了这个目录下面所有的文件名字
String ss[] = list();
if (ss == null) return null;
// 创建了一个存储File对象的集合
ArrayList files = new ArrayList<>();
// 迭代这个名字的数组
for (String s : ss) {
// 使用文件名, 创建了一个对应的File对象
File f = new File(s, this);
if ((filter == null) || filter.accept(f))
// 当accept方法返回true, 将这个文件对象加入到list列表中
files.add(f);
}
// 将list变成数组返回
return files.toArray(new File[files.size()]);
}
筛选出你要的文件代码应用：代码还可以使用Lambda表达式简化

 File file = new File(".");
        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File f) {
                // 只想保留文件, 不想保留目录
                return f.isFile();
            }
        });
        System.out.println(Arrays.toString(files));

        File[] files1 = file.listFiles((File f) -> {
                // 只想保留 txt 文件
                String name = f.getName();
                return name.endsWith(".txt");
            });
        System.out.println(Arrays.toString(files1));
        // 所有文件都保留
        file.listFiles(f -> true);

2.路径:

绝对路径: window是 - 从盘符开始 C:\xx\xx…
Linux是 - /xx/xx (从根目录开始)
相对路径: 会有一个参照对象 a.txt
参考值: /Users/bonnie/Desktop 相对路径是: a.txt
那么a.txt的真实路径: /Users/bonnie/Desktop/a.txt
现在a.txt的真实路径: /Users/bonnie/IdeaWorks/corejava/API_day09/a.txt
那么现在的参考值: /Users/bonnie/IdeaWorks/corejava/API_day09

参考值我们称之为 - 当前目录
参考值: C:\IdeaWorks\day09\src 相对路径: com/zzxx/demo01/a.txt
那么a.txt的真实路径: C:/IdeaWorks/day09/src/com/zzxx/demo01/a.txt
. : 当前目录 - 现在的参考值
…: 上一级目录 - 现在的参考值往上一层
根据相对路径, 获得当前程序环境下的绝对路径
复习: 1.xx.class.getResource(“相对路径”) -> 得到一个绝对路径
2.xx.class.getClassLoader().getResource(“相对路径”) -> 得到一个绝对路径
注意:
类路径 classpath: 就是src编译后的目录, 也叫编译根目录
以上 1 和 2 代码得到的绝对路径, 都是在编译后的目录中, 和src没有直接关系
在开发中, 我们是先将文件放入src中的, 会自动编译到类路径中

 @Test
    public void test01() {
        File file = new File("a.txt");
        // a.txt 的路径参考值: 当前这个 module
        System.out.println(file.getAbsoluteFile());
    }
    @Test
    public void test02() {
        String path = Demo03Path.class.
                getResource("a.txt").getPath();
        // a.txt 路径的参考值: 当前类的编译目录 - 就是当前这个包
        // 直接理解为: a.txt 和 当前这个类 同一个包
        // /Users/bonnie/IdeaWorks/corejava/out/production/API_day09/com/zzxx/a_file/a.txt
        System.out.println(path);
    }
    @Test
    public void test03() {
        String path = Demo03Path.class.getClassLoader()
                .getResource("b.txt").getPath();
        // b.txt 路径的参考值: 当前这个模块编译后的根目录 classpath - 类路径
        // 直接理解为: b.txt 就是在src下的
        // /Users/bonnie/IdeaWorks/corejava/out/production/API_day09/b.txt
        System.out.println(path);
    }

3.IO 流

1.以单位来分: 字节流字符流
2.以层级来分: 底层流包装流

字节流: InputStream/OutputStream
子类: FileInputStream/FileOutputStream
字符流: Reader/Writer

构造方法

@Test
    public void test01InputStream() throws FileNotFoundException {
        InputStream is = new FileInputStream(new File("a.txt"));
        InputStream is1 = new FileInputStream("a.txt");
    }

    @Test
    public void test01OutputStream() throws FileNotFoundException {
        OutputStream os = new FileOutputStream(new File("a.txt"));
        OutputStream os1 = new FileOutputStream("a.txt");
        // 在原有的文件末尾上追加内容
        OutputStream os2 = new FileOutputStream("a.txt", true);
        OutputStream os3 = new FileOutputStream(new File("a.txt"), true);
    }

注意:
1.IO所有跟文件相关的流中, 构造方法中需要File作为参数的都可以使用文件路径直接取代
2.字节流写和读都是以字节为单位的, 单个字节能不能正常显示出来, 是不确定的

字节流API:

void write(int) : 写入这个int值得低八位
int read() : 读文件中一个字节, 并且存入int的低八位, 其余空位补0
当返回 -1 的时候, 说明文件读到了末尾

 @Test
    public void test01Write() throws IOException {
        // a.txt 现在不存在
        /*
          如果文件不存在, 会创建新的文件, 然后再写入内容
          如果文件存在, 会清空原来的内容, 然后再写入
         */
        OutputStream os = new FileOutputStream("a.txt");
        // 以字节为单位写入, 只写入一个字节
        // 00000000 00000000 00000001 00000000
        os.write(229);
        os.write(147); // 'a' = 97
        os.write(136); // 'A' = 65
        os.write(48); // '0' = 48
        // 10000000 00000000 00000000 00000001
        // 反:11111111 11111111 11111111 11111110
        // 补:11111111 11111111 11111111 11111111
        os.write(-1); // 11111111
    }
    @Test
    public void test01Read() throws IOException {
        /*
           如果文件不存在, 就会抛出 FileNotFoundException
         */
        InputStream is = new FileInputStream("a.txt");
        // 读一个字节 8位 放入int的 32位 中的低八位, 其他空位都补0
        int i ;
        while((i = is.read()) != -1) {
            System.out.println("i:" + i);
        }
    }
    @Test
    public void copy() throws IOException {
        InputStream is = new FileInputStream("a.txt");
        OutputStream os = new FileOutputStream("a_bak.txt");
        int i ;
        while((i = is.read()) != -1) {
            os.write(i);
        }
    }

WinWinWinooo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
API-Day09——File-文件类、路径、IO流

回顾:线程通信: 共享资源wait()notify()wait(long)notifyAll()线程池: ExecutorServiceExecutors -> 生产各种线程池对象的工厂类1.单线程的2.固定数量的3.Cached 根据需求来创建线程对象的4.Schedule 定时执行Lambda表达式1.实现函数式接口 @FunctionalInterface2.作为方法参数使用(参数列表) -> {方法体}1.参数列表的类型可以省略2.参数只有一个, ()
复制链接

扫一扫

专栏目录