Java学习与复习笔记--过滤器&IO字节输出流

最新推荐文章于 2022-01-17 21:40:53 发布

gokx

最新推荐文章于 2022-01-17 21:40:53 发布

阅读量171

点赞数

分类专栏： File类与IO流文章标签： java

本文链接：https://blog.csdn.net/gkx826/article/details/108270386

版权

File类与IO流专栏收录该内容

8 篇文章 0 订阅

订阅专栏

FileFilter过滤器的原理和使用：

/*
 * 定义一个方法，参数传递File类型的目录
 * 方法中对目录进行遍历
 * 只要.txt结尾的文件
 * 我们可以使用过滤器来实现
 * 在File类中有两个和ListFiles重载的方法，方法参数传递的就是过滤器
 * File[] listFiles(FileFilter filter) ：
 * java.io.FileFilter接口：用于抽象路径名（File对象）的过滤器
 * 作用：用来过滤文件的
 * 抽象方法：boolean accept(File pathname)测试指定抽象路径名是否应该包含在某个路径名列表中。
 * 参数：File pathname：使用ListFile方法遍历目录，得到的每一个文件对象
 * String[] list(FilenameFilter filter)：
 * java.io.FilenameFilter接口：实现此接口的类实例可用于过滤器文件名
 * 作用：用于过滤文件名称
 * 抽象方法：boolean accept(File dir,String name)：测试指定文件是否应该包含在某一文件列表中。
 * 参数：File dir：构造方法中传递的被遍历的目录
 * String name：使用ListFiles方法遍历目录，获取的每一个文件/文件夹的名称
 * 注意：两个过滤器接口是没有实现类的，需要我们自己写实现类，重写过滤的方法accept，在方法中自己定义过滤的原则。
 * */
public class Demo01Filter {
    public static void main(String[] args) {
        File file=new File("D:\\abc");
        getAllFile(file);
    }
    /*
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     * 只要.txt结尾的文件
     * */
    public static void getAllFile(File dir){
        //System.out.println(dir);//打印被遍历的目录名称
        File[] files = dir.listFiles(new FileFilterImpl());//传递过滤器对象
        for (File file : files) {
            //对遍历得到的File对象 file进行判断
            if(file.isDirectory()){
                //file是一个文件夹，则继续遍历这个文件夹
                //直接调用getAllFile方法即可：递归（自己调用自己）。
                getAllFile(file);
            }else {
                    System.out.println(file);
            }
        }
    }
}
/*
* 创建过滤器FileFilter的实现类，重写过滤方法accept，定义过滤规则
* */
public class FileFilterImpl implements FileFilter{
    /*
    * 过滤的规则：
    * 在accept方法中，判断File对象是否是以.txt结尾
    * 是就返回true
    * 不是就返回false
    * */
    @Override
    public boolean accept(File pathname) {
        //如果pathname是一个文件夹，返回true，继续遍历这个文件夹
        if(pathname.isDirectory()){
            return true;
        }
        return pathname.getName().toLowerCase().endsWith(".txt");
    }
}

FileNameFilter过滤器的使用匿名内部类和Lambda表达式简化：

public class Demo02Filter {
    public static void main(String[] args) {
        File file=new File("D:\\abc");
        getAllFile(file);
    }
    /*
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     * 只要.txt结尾的文件
     * */
    public static void getAllFile(File dir){
        /*//传递过滤器对象,使用匿名内部类
        File[] files = dir.listFiles(new FileFilter() {
            //过滤规则
            @Override
            public boolean accept(File pathname) {
                //如果pathname是一个文件夹，返回true，继续遍历这个文件夹
                if(pathname.isDirectory()){
                    return true;
                }
                return pathname.getName().toLowerCase().endsWith(".txt");
            }
        });*/
        //使用Lambda表达式优化
        /*File[] files=dir.listFiles((File pathname)->{
            if(pathname.isDirectory()){
                return true;
            }
            return pathname.getName().toLowerCase().endsWith(".txt");
        });*/
        //继续优化Lambda表达式
        File[] files=dir.listFiles(pathname-> pathname.isDirectory()||pathname.getName().toLowerCase().endsWith(".txt"));
        /*File[] files=dir.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir,name).isDirectory()||name.toLowerCase().endsWith(".txt");
            }
        });*/
        //Lambda表达式优化匿名内部类（接口中只有一个抽象方法）
        /*File[] files=dir.listFiles((File d,String name)->{
            return new File(d,name).isDirectory()||name.toLowerCase().endsWith(".txt");
        });*/
        //继续优化Lambda表达式
        /*File[] files=dir.listFiles((d, name)->
             new File(d,name).isDirectory()||name.toLowerCase().endsWith(".txt")
        );*/
        for (File file : files) {
            //对遍历得到的File对象 file进行判断
            if(file.isDirectory()){
                //file是一个文件夹，则继续遍历这个文件夹
                //直接调用getAllFile方法即可：递归（自己调用自己）。
                getAllFile(file);
            }else {
                    System.out.println(file);
            }
        }
    }
}

IO概述（概念&分类）：

I：input输入（读取）

O：output输出（写入）

流：数据（字符，字节）1个字符=2个字节 1个字节=8个二进制位

硬盘-》内存：输入，把硬盘中的数据，读取到内存中使用

内存-》硬盘：输出：把内存中的数据，写入到硬盘中保存

字节流：一切皆为字节

字节输出流-OutputStream类&FileOutputStream类：

/*
* java.io.OutputStream:字节输出流，表示字节输出流的所有类的超类。
* 定义了一些子类共性的成员方法：
* void close() 关闭此输出流并释放与此流相关联的任何系统资源。
* void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。
* void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
* void write(byte[] b, int off, int len) 从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
* abstract void write(int b) 将指定的字节写入此输出流。
* java.io.FileOutputStream extends OutputStream
* FileOutputStream:文件字节输出流
* 作用：把内存中的数据写入到硬盘的文件中。
* 构造方法：
* FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
* FileOutputStream(String name) ：创建文件输出流以指定的名称写入文件。
* 参数：String name：目的地是一个文件的路径
*       File file：目的地是一个文件
* 构造方法的作用：
* 1.创建一个OutputStream对象
* 2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
* 3.会把FileOutputStream对象指向好的文件
*
* 写入数据的原理：由内存到硬盘
* java程序-->JVM（java虚拟机）-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中
* 字节输出流的使用步骤（重点）：
* 1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
* 2.调用FileOutputStream对象中的方法write，把数据写入到文件中
* 3.释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提高程序的效率）
* */
public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos=new FileOutputStream("FileAndIO\\a.txt");
        //2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        //abstract void write(int b) 将指定的字节写入此输出流。
        fos.write(97);
        //3.释放资源
        fos.close();
    }
}

文件存储的原理和记事本打开文件：

写数据的时候，会把10进制的整数，转化为二进制的整数

fos.write(1100001);97-->1100001,硬盘中存储的数据都是字节 1个字节=8个比特位（10101010）

任意的文本编辑器（记事本，notepad++...）再打开文件的时候，都会查询编码表，把字节转换为字符表示

0-127：查询ASCII表

97--》a

其他值：查询系统默认码表（中文系统GBK）

字节输出流写多个字节的方法：

/*
* 一次写多个字节的方法：
* void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
* void write(byte[] b, int off, int len) 从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
* */
public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //创建OutputStream对象，构造方法中绑定要写入数据的目的地
        FileOutputStream fos=new FileOutputStream(new File("FileAndIO\\b.txt"));
        //在文件中显示100，写3个字节
        /*fos.write(49);
        fos.write(48);
        fos.write(48);*/
        /*
        * void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
        * 一次写多个字节：
        * 如果写的第一个字节是正数（0-127），那么显示的时候会查询ASCII表
        * 如果写的第一个字节是负数，那么第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认码表（GBK）
        * */
        byte[] bytes={65,66,67,68,69};//ABCDE
        //byte[] bytes={-65,-66,-67,68,69};//烤紻E
        fos.write(bytes);

        /*
        * void write(byte[] b, int off, int len) 从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
        * 把字节数组的一部分，写入到文件中
        * int off：数组的开始索引
        * int len：写几个字节*/
        fos.write(bytes,1,2);//BC
        /*
        * 写入字符的方法：可以使用String类中的方法把字符串，转化为字节数组
        * byte[] getBytes() ：把字符串转换为字节数组 */
        byte[] bytes1 = "你好".getBytes();//[-28, -67, -96, -27, -91, -67]
        System.out.println(Arrays.toString(bytes1));
        fos.write(bytes1);
        fos.close();
    }
}

字节输出流的续写和换行：

/*
* 追加写/续写：使用两个参数的构造方法
* FileOutputStream(String name, boolean append) ：创建文件输出流以指定的名称写入文件。
* FileOutputStream(File file, boolean append) ：创建文件输出流以写入由指定的 File对象表示的文件。
* 参数：
* String name,File file：写入数据的目的地
* boolean append:追加写开关 true：创建对象不会覆盖原文件，继续在文件的末尾追加写数据
*                          false：创建一个新文件覆盖原文件
* 换行符号：Windows：\r\n
* Linux:/n
* mac:/r
**/
public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("FileAndIO\\c.txt",true);
        for (int i = 0; i <10 ; i++) {
            fos.write("你好".getBytes());
            fos.write("\r\n".getBytes());//换行
        }

        fos.close();
    }
}