一、过滤器
FiLe类中有两个ListFiles( ) 重载的方法,这两个重载的方法的参数，传递的就是过滤器 而在java中，有两种过滤器分别是FileFilter接口和FileNameFilter接口。
FileFilter接口
????????在java.io包下的FileFilter接口，顾名思义，FiLeFilter接口的作用就是用于抽象路径名(FiLe对象)的过滤器，它是File的一个过滤器。该接口的对象可以传递给File类的File[] listFiLes(FiLeFilter filter)作为参数，接口中只有一个方法：
boolean accept(File pathname)用于测试pathname(抽象路径)是否包含在当前File目录中，如果在，返回true，不在，则返回false…
FiLeNameFilter接口
????????在java.io包下的FiLeNameFilter接口，它也是File的过滤器。顾名思义，FiLeNameFilter接口的主要做用是用于过滤文件名称，而且实现了此接口的类的实例可以用作过滤器文件名。 该接口的对象可以传递给File类的FiLe[] ListFiLes(FiLeNameFilter filter)作为参数，接口中只有一个抽象方法：
boolean accept(File dir，String name）该方法是用来测试指定的文件是否包含在某一文件列表中，其中的 File dir为构造方法中传递的被遍历的目录；而String name为使用ListFiles方法遍历目录获取到的每一个文件或者文件夹的名称。
注意：上面的两个过滤器接口都是没有实现类的，要使用时，需要自己写它们的实现类，并且要重写接口中的accept()方法，用于定义过滤的规则。
二、IO流
（1）概述
????????IO指的就是输入(input)和输出(output)，而流是一个抽象的概念，是对数据传输的一个总称；IO流指的就是数据的输入刘和输出流，是用来处理设备之间数据传输问题，例如：文件的上传、下载、复制、剪切。。。。
在计算机中：输入流（也就是读取数据）从硬盘传输到内存中；同样的，输出流（也就是写入数据）从内存传输到硬盘中。
（2）分类
1.根据数据的流向可以分为:输入流 和 输出流。
- 输入流︰把数据从其他设备上读取到内存中的流。
- 输出流︰把数据从内存中写出到其他设备上的流
2.根据传输的数据的类型分为:字节流 和 字符流。
- 字节流:还包括字节输入流（InputStream），字节输出流(OutputStream)
- 字符流:也包括字符输入流(Rader)，字符输出流(Writer)
1.字节输出流
（1）OutputStream字节输出流
????????这个抽象类表示字节输出流的所有类的父类
该类中定义了一些共性的成员方法：
public void close():关闭此输出流并释放与此流相关联的任何系统资源。
public void flush()﹔刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[ ] b):
将b.Length字节从指定的字节数组写入此输出流。
public void write(byte[ ] b, int off, int len):
从指定的字节数组写入Len字节，从偏移量off开始输出到此输出流。
public abstract void write(int b):将指定的字节输出流。
（2）FileOutputStream文件字节输出流
????????FileOutputStream extends OutputStream
FileOutputStream类的作用就是把内存中的数据写入到硬盘的文件中
FileOutputStream 类 常用的构造方法:
- FiLeOutputStream( String name):
创建一个向具有指定名称的文件中写入数据的输出文件流。
String name：参数表示目的地是一个文件的路径 - FiLeOutputStream(File fiLe):
创建一个向指定 file 对象表示的文件中写入数据的文件输出流。
File file：参数表示目的地是一个文件
构造方法的功能;
- 1.创建一个FileOutputStream类的对象
- 2.根据构造方法中传递的文件或者文件的路径，创建一个空的文件
- 3.将FileOutputStream类的对象指向已经创建好的文件
（3）字节输出流的使用步骤
- 1.创建一个FileOutputStream类的对象，在构造方法中传逸要写入数据的目的地（文件路径）
- 2.调用FileOutputStream类的对象中的write()方法 来把数据写入到文件中
- 3.释放资源，因为使用流时会占用一部分内存，使用完流后需要释放该内存资源，提高程序的使用效率。
注意：我们调用write方法写入十进制的整数，在执行程序时，会将其转换为二进制的整数，也就是说我们向磁盘中写入的数据是二进制的数据，但是我们打开文件的时候看见的是字符串，那因为我们使用的文本编辑器（记事本，notpad++, sublime等），它自带了将二进制字节码转换为字符的逻辑，根据查询到的编码表，将字节转换为字符。
我们来看个实例演示代码;
//1.创建一个FiLeOutputStream对象,构造方法中传逸写入数据的目的地
FileOutputStream fos = new FileOutputStream("D:\\BigData\\java\\javalearn\\src\\com\\data\\test_fos.txt");
//2.调用FiLeOutputStream对象中的方法write ,把数据写入到文件中
//public abstract void write(int b):将指定的字节输出流。
fos.write(97);
fos.write('\n');//换行
//public void write(byte[ ] b):将b.Length字节从指定的字节数组写入此输出流。
byte[] bytes={98,99,100,101,102,122};
fos.write(bytes);
fos.write('\n');
//public void write(byte[ ] b, int off, int len):从指定的字节数组写入Len字节，从偏移量off开始输出到此输出流。
fos.write(bytes,1,3);
//若是写入一个字符串，那么我们要使用到getBytes()方法
fos.write('\n');
String str ="你好，大佬！欢迎来到北慕辰的博客！给个三连鼓励鼓励！";
byte[] strBytes = str.getBytes();
//打印字节码
System.out.println(Arrays.toString(strBytes));
fos.write(strBytes);
//3.释放资源，因为使用流时会占用一部分内存，使用完流后需要释放该内存资源，提高程序的使用效率。
fos.close();
上面的代码我们在测试时会发现，每次运行代码时，文件内容都会被覆盖掉，详细演示一下：
第一次执行：
第二次执行：
为了解决这种问题，FiLeOutputStream类中提供了两种构造方法;
一、在文件末尾追加
1. FileOutputStream(String name，boolean append )
创建一个向具有指定name的文件中写入数据的输出文件流
2. FileOutputStream(File file，boolean append)
创建一个向指定的File对象表示的文件中写入数据的文件输出流
简单说明下各参数：
String name , File fiLe:要写入数据的文件路径
boolean append;
给定true:每次执行代码不会匿羞源文件,在文件追末尾追加
给定false:每次执行代码，在文件末尾无法追加，会覆盖源文件
二、每写入一次数据，换一次行
Windows下是 "\r\n"
Linux下是 "/n"
看个实例;
//1.创建一个FiLeOutputStream对象,构造方法中传逸写入数据的目的地
FileOutputStream fos = new FileOutputStream("D:\\BigData\\java\\javalearn\\src\\com\\data\\test_fos.txt",true);
File file = new File("D:\\BigData\\java\\javalearn\\src\\com\\data\\test1_fos.txt");
FileOutputStream fos1 = new FileOutputStream(file, true);
//2.调用FiLeOutputStream对象中的方法write ,把数据写入到文件中
fos.write(97);//执行一次写入一次，不会覆盖了
fos1.write("北慕辰".getBytes());
//实现换行写
String str ="北慕辰";
for (int i = 0; i < 5; i++) {
String s =str + Integer.toString(i);//小小的拼接
fos1.write("\r\n".getBytes());//换行
fos1.write(s.getBytes());
}
//3.释放资源，因为使用流时会占用一部分内存，使用完流后需要释放该内存资源，提高程序的使用效率。
fos.close();
fos1.close();
2.字节输入流
（1）InputStream字节输入流
???????? InputStream抽象类，是表示字节输入流的所有类的根类。
该类中定义了一些共性的成员方法：
int read() 从输入流中读取数据的下一个字节。
int read(byte[] b)
从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
void close()关闭此输入流，并释放与该流关联的所有的系统资源。
（2）FileInputStream文件字节输入流
????????FileInputStream extends InputStream
FileInputStream类的作用就是把硬盘文件中的数据读取到内存中
构造方法;
FileInputStream(String name)
FileInputStream( File file)
String name:文件的路径
File file;文件
构造方法的作用:
1.创建一个FileInputStream类的对象
2.给FileInputStream类的对象，指定构造方法中要读取的文件
（3）字节输入流的使用步骤
- 1.创建FileInputStream类的对象，并在构造方法中指定要读取的数据源
- 2.使用FileInputStream对象中的read()方法读取文件
- 3.调用close方法释放资源
看个实例代码演示：
//1.创建FileInputStream类的对象，并在构造方法中指定要读取的数据源
FileInputStream fis = new FileInputStream("D:\\BigData\\java\\javalearn\\src\\com\\data\\test_fis.txt");
//2.使用FileInputStream对象中的read()方法读取文件
//read()方法读取一个字节，当读到文件末尾返回-1
/*int read = fis.read();
System.out.println(read);//97--a
int read1 = fis.read();
System.out.println(read1);//98--b
int read2 = fis.read();
System.out.println(read2);//99-c
int read3 = fis.read();
System.out.println(read3);//100-d
int read4 = fis.read();
System.out.println(read4);//-1
int read5 = fis.read();
System.out.println(read5);//-1 */
//使用循环读取
/* int r= 0;//接收每次读取的字节
while ( (r=fis.read()) != -1){
System.out.println(r);
//System.out.println((char)r);//转换成字符
}*/
//使用数组来接收
int r = 0;//接收每次读取的字节
byte[] bytes= new byte[4];
while ( (r=fis.read(bytes)) != -1){
}
System.out.println(Arrays.toString(bytes));
//3.调用close方法释放资源
fis.close();
3.字节流案例
案例一、使用文件输入流，统计代码行数
public class demo_countlines {
static int countline=0 ;//静态全局变量，接收行数
public static void main(String[] args) throws Exception {
File file = new File("D:\\BigData\\java\\javalearn\\src");
countLines(file);
System.out.println(countline);
}
public static void countLines(File file)throws Exception{
File[] files = file.listFiles();
for (File file1 : files) {
if (file1.isFile() && file1.getName().endsWith(".java")){
//创建file1字节流
FileInputStream fileInputStream = new FileInputStream(file1);
//统计代码行数
int f;
while ((f=fileInputStream.read())!= -1){
if (f =='\n'){
countline++;
}
}
fileInputStream.close();
}else if (file1.isDirectory()){
countLines(file1);
}
}
}
。。。。。请忽略代码行数。。。小北学了这么多天了，才敲了这么点代码 。有愧于自己啊，啊啊啊啊。。。还要继续努力，嗯，加油，我可以的。
案例二、使用字节流，实现文件复制
public static void main(String[] args) throws IOException {
File oldfile = new File("D:\\BigData\\java\\javalearn\\src\\com\\data");
File newwfile = new File("D:\\BigData\\java\\javalearn\\src\\com\\data_copy");
fileCopy(oldfile,newwfile);
}
public static void fileCopy(File oldFile, File newFile)throws IOException {
//1.判断目标目录是否实际存在,不存在则创建目标目录
newFile.mkdirs();
//2.返回oldFile中的文件/文件夹集合
File[] files = oldFile.listFiles();
//3.遍历files,判断是文件还是目录
for (File file : files) {
if(file.isFile()){
//3.1 file为文件，那么就复制到newFile
//3.1.1 读取文件中的数据，
// 创建指向file的文件字节输入流
FileInputStream fis = new FileInputStream(file);
//3.1.2 向文件中写入数据，
// 创建指向匿名对象new File(newFile,file.getName()) 的文件字节输出流
// new File(newFile,file.getName()) 文件类的构造方法
FileOutputStream fos = new FileOutputStream(new File(newFile,file.getName()));
//3.1.3 开始复制文件
int sum;//记录每次读取的字节数据
while ((sum=fis.read())!=-1){//while循环复制读写数据
fos.write(sum);
}
//3.1.4 释放内存资源
fos.close();
fis.close();
// file.delete(); //删除oldFile中源文件，实现剪切功能
}else {//如果file为文件夹
//根据file文件夹的名称，在newFile中创建一个一样的文件夹
File newfile = new File(newFile, file.getName());
newfile.mkdirs();
//若file文件夹中还有文件/文件夹，递归调用本身方法继续复制
fileCopy(file,newfile);
}
}
//oldFile.delete(); //删除oldFile源文件，实现剪切功能
}
}
测试结果截图;
制作不易，各位友友们，大佬们给点鼓励！
点赞👍 👍 👍 收藏+关注 一键三连走起！
