1、函数式编程：强调做什么，而不是以什么形式做
2、New thread( (可带参数)->{方法体sout(直接打印的信息);});
3、Lambda只有函数式接口可以使用，替换内部类，只有一个抽象方法的
4、Lambda的表达式标准格式
(1)一些参数（列表中的数据类型可以省略不写，如果只有一个参数，类型和（）都可以省略）
(2)一个箭头
(3)一段代码，// 只有一行代码的时候，{}和;都可以省略，而且无论是否有返回值都可以省略{}，return，分号，但是要省略就一起省略
(4)（参数列表）->{一些重写方法的代码}
①（）接口中抽象方法的参数列表，没有就空着，多个参数，隔开
②->把参数传递给后面方法体
③{}重写接口的抽象方法的方法体
5、lambda的使用前提：
(1)函数式接口
(2)必须可以推导出来
6、线程池
(1)线程池是一个容纳多个线程的容器，可反复使用，省区了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源
(2)提高相应的速度
(3)提高了线程的可管理性
7、线程池的代码操作
(1)ExecutorService a=Executors.newFixedThreadPool(nThreads:5);
a.submit(线程接口new Rannable(){重写run()方法});// 增加一个线程，并开启，用完了之后放回到线程池
a.shutdown();// 销毁线程池，后面再次调用线程池线程将报错
1、与系统有关的分隔符
(1)String S=File.pathSeparator;// 在Windows系统结果是 ; 而Linux系统则是:
(2)String s=File.separator;// winodws中是\，而Linux中是/，故为了都能用所以格式
用的是C:\der\wfgr\a.txt
转变为”C:”+File.separator+”der”+File.separator+”wfgr”+File.separator+”a.txt”格式
2、”\”转义符，因为双引号或者反斜杠在代码中被看作是字符，所以需要打印直接输入的时候需要转义符，例如sout( “D:\\asd\\as\\a.txt”);//输出结果为 D:\asd\as\a.txt
3、绝对路径：以盘符开始的路径，如：C:\\ad\\asdaf\\a.txt;
4、相对路径：一个简化的路径，相对指相当于当前项目的根目录，
如：C:\\ad\\asdaf\\a.txt，相对的时候->  a.txt;
5、File的方法
(1)File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);// 不考虑路径真假情况，只是把字符转封装为File对象，重写了toString()方法，相对，绝对路径都可以存
(2)File fi=new File(“C:\\aef\\efsg”,”asd\\ss\\x\\z.txt”);// 输出结果为字符串的拼接
参数为父路径和子路径，使用灵活，都可以变化
(3)File fi2=new File(fi,”ada\\a\\z.txt”); // 输出还是为fi路径与字符串的拼接，这样父路径可以单独写
(4)File fi=new File(“\\efsg\\z.txt”);
①fi.getAbsolutePath();// 获取当前对象的绝对路径C:\aef\efsg\z.txt
②fi.getPath();// 获取当前file对象构造中传入的路径 efsg\z.txt
③fi.fetName();// 获取当前文件的名称 z.txt
④long length=fi.length(); // 当前文件的大小 0
// 文件夹没有大小，只有文件才有大小。
6、File类判断方法
File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);
(1)Boolean b=fi.exists(); // 判断该路径是否真实存在，真true假false，相对与绝对路径都可以判断
(2)Boolean b2=fi.isDirectory();// 判断给的路径是否以文件夹结尾
(3)Boolean b3=fi.isFile(); // 判断给的路径是否以文件结尾，与上面是互斥的，
因为电脑硬盘中只有文件或者文件夹，使用前提，路径存在
7、File类创建与删除方法
File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);
(1)Boolean b=fi.createNewFile(); // true文件不存在，fi传递的文件a.txt创建成功，false则表示文件已存在，不会创建，此方法只能创建文件 ，不能创建文件夹，但是创建的文件路径必须存在，否则报错
File fi=new File(“C:\\aef\\efsg”);
(2)Boolean b=fi.mkdir();// 创建单级文件夹,不存在则建，存在则false
File fi=new File(“C:\\aef\\efs\\111\\222\\333”)
(3)Boolean b=fi.mkdirs();// 创建多级文件夹，也可以创建单级的
(4)Boolean b=fi.delet();// 删除文件/文件夹，但是文件夹里面有文件时，文件夹不能直接删除，会输出false，必须先删除文件，并且此删除不走回收站，硬盘中直接删除，谨慎



8、File文件夹的目录的遍历
(1)格式1：File fi=new File(“C:\\aef\\efsg”);// 会先判断文件夹存不存在，如果不存在会包异常，可以再次判断是否为文件夹，fi.isDirectory();
String [] arr1=fi.list(); // 返回的是String数组，元素是第一层的文件夹/文件名字
for(File f1:arr1){
sout(fi);// 直接打印绝对路径，
}
(2)格式2：File fi=new File(“C:\\aef\\efsg”);// 先判断是否为文件夹，fi.isDirectory();
File [] f2 = fi.listFiles();// 返回文件数组，存的是文件// 文件从硬盘存到内存中
For(File f:f2){
Sout(f);// fi.getName();就是打印文件(夹)名,隐藏文件都可以打印
// 在遍历中可以删除文件，不报并发异常，因为删除文件不影响数组长度变化，删除的是硬盘上的文件，数组中的是存在内存中的。
}
9、递归，当前方法内调用自己
(1)格式1：直接递归：main()调用a();,a()又调用a()自己;
(2)格式2：间接递归：main()调用a(),a()调用b(),b()又调用a();
使用注意，要保证递归能够停下来，不然会栈内存溢出，构造方法禁止递归，不然会创建无数个对象，而且递归的次数不能过多，否则也可能超出栈内存
10、用递归遍历给出的文件夹
(1)Public class Test01{
P s v m{
File fi=new File(“C:\\aaa\\afD\\xas”); // 给一个文件夹
getAllFile(fi); // 调用遍历方法
}
Public static void getAllFile(File f1){
Sout(fi); // 打印一下该文件夹的名字
File [] f2=f1.listFiles(); // 把给定的文件夹，文件数组化
for(File f:f2){   // 遍历
if(fi.isDirectory){  // 是文件夹则true
getAllFile(fi);  // 是文件夹就再次递归，来遍历此文件夹
} else {
Sout(f); // 不是文件夹，就直接打印，可以f.getName();打印名字
// 如果要获得特定结尾的文件，就需要获取名字，然后小写化（需要的话）f.getName().toLowerCase().endsWith(“\.txt”);指定打印以.txt结尾的文件，
}
}
}
}
// 输出的就是此文件夹之下的所有文件




11、文件过滤器，获得指定结尾的文件，以FileFilter接口实现的，实现类中重写其中的
accept()方法(过滤方法)，其中传入遍历的文件，
Public class GuoLvQi {  
Psvm(){
File dir=new File(“C:\\aaa\\afD\\xas”); // 获取一个文件夹
getAllFile(dir);  // 调用方法
}
Public static void getAllFile(File dir){
File fi=dir.listFiles(new FileFilterimpl()),// listFiles带参数的重载方法，new实现类
For(File f:fi){  // 遍历
If(f.isDirectory()){ // 是否为文件夹
getAllFiles(f); // 递归调用
}else {
Sout(f); // 是文件则直接打印
}
}
}
}
实现类：
Public class fileimpl implement FileFilter{ // 实现FileFilter接口
@override
Public boolean accept(File f){  // 重写accept()方法
If(f.isDirectory()){  
Return true; // 是文件夹返回true
}
Return f.getName().toLowerCase().endsWith(“\.txt”); // 是文件则判断结尾并返
}
}
listFiles它会对构造方法中传递的目录进行遍历，获取文件(夹)封装为File对象，并调用accept方法，且会把遍历得到的每一个File对象，传递给accept方法的参数，然后返回一个布尔值，如果是true，就会把File对象保存到File[] fi中，否则不存。所以过滤器规则就写在accept()方法中
1、IO流：输入输出流，从硬盘(读取到)->内存就是输入，从内存->(写入到)硬盘就是输出。
2、一个字符等于2个字节，一个字节=8个二进制位
图片，视频，音频，都是字节保存的，都用字节流，不用字符流（可能会出错）
3、字节输出流（保存）：OutputStream顶层父类（抽象类），
FileOutputStream（子类）,（往文件中写数据）文件字节输出流
常用方法步骤：
先要创建对象，
FileOutputStream fos=new FileOutputStream(name:”11/aaa.txt”，append:teue);参数：指定路径创建一个文件,但是文件是在关闭流（有fos.close）的时候才创建的，不关流也可以创建。后面加append：true，是续写，不会覆盖之前的数据；加append：false，指创建一个新的文件，覆盖原文件
new FileOutputStream可以默认创建一个文件
(1)fos.write(int a);// 写入一个字节，数据写入文件
(2)fos.write(byte[] bytes);//写入一个字节数组
可用(String类型) str.getBytes();字符串转字节数组
如果写的第一个字节是负数，第一和第二字节会组成一个中文显示，2字节=1中文
(3)fos.write(bytes,int off,int len);// 写入字节数组中的一部分，bytes是数组，off是数组起始的索引值，len是写入几个字节（数据的长度）
(4)fos.close();// 写入完毕必须要关闭流，清空->为了释放资源，因为流会占用内存，
如果不用fos.write()写入数据直接创建，此空文件就会覆盖同名文件，但是有append的时候就只是没有新的数据续写而已，文件不会被覆盖为空
(5)写换行，windows格式:fos.write( “\r\n”.getBytes()); //跳到下一行开头  linux:/n   mac:/r
4、字节输入流：FileInputStream,把硬盘中的数据读取到内存中使用
常用方法使用步骤：
(1)创建FileInputStream对象，绑定要读取的数据源
①FileInputStream fis=new FileInputStream(“a.txt”);// 读取数据源
(2)Int a1=fis.read();// 返回的是一个字节，读取到文件的末尾(没有元素了)返回-1；读取的时候，取完元素后，指针会向后移动一位，                                                                              因为是重复，可用while循环
①Int len=0;// 需要变量，否则容易漏读等，read()一次就读写一次，故此谨慎
②While ((len=fis.read())!=-1){ // 读取一个字节，赋值给变量，判断=-1否，并且指针指向下一个字节，
Sout((char)len);// int转换为字符输出
}
3)Byte [] bytes=new byte[1024];// 定义一个字节数组，读取多个字节，起到了缓冲的作用，数组长度可以小于要读取的文件字节总数，fis.read(bytes);小于的时候就是长度为几，就先读取几个，后面再继续，通常定义1024个字节或其整数倍
本质也是一个一个的读，先从硬盘(一个一个)到内存(字节数组)，再从内存(数组)到JVM(数组)，提高的效率在于从内存到JVM的过程
4)Int len = fis.read(bytes); // 读取文件的字节，并保存到字节数组中，len接收返回的读取的字节个数，
5)Sout(len);
6)Sout(new String(bytes,0,len));// 读取的字节数组字符串化，从索引0开始，输出        len个字符(减去索引值起始位置之后，不能超出数组的长度)
读取可以用while循环，直到读完。(读取中文的时候容易出错)
(3)fis.close();// 同理关流。
5、字符输入流：Reader抽象类，用其子类FileReader文件字符输入流，
主要用来输入中文，常用方法，步骤
(1)FileReader fr=new FileReader(文件路径); // 建一个对象
(2)Char[] ch=new char[1024]; // 建一个char数组
(3)Int len=0; // 变量来接收读取的字符个数
(4)While((len=fr.read(ch))!=-1){ // 判断读取的字符个数=-1否，数组到最后取完字符的时候，下一次会跳到结束指令符，直接返回-1，而不是取到的字符长度
Sout(new String(ch,0,len)); // 以字符串的形式输出
Sout((char)len);// 或者直接以字符输出，一个一个读的时候用
}
fr.close(); // 关闭流
6、字符输出流：FileWrite extends OutputSream类
(1)FileWrite fw=new FileWrite (写入数据目的地文件路径);
(2)fw.write(); // 写入字符
(3)fw.write(“xfezfes”);// 字符串可以直接写入字符
(4)fw.flush();// 把内存缓冲区的数据，刷新到文件中，输出流都有该方法，而输入流没有，刷新后流还可以继续使用，
(5)fw.close();// 把内存缓冲区的数据，刷新到文件中，并且关闭流
7、Properties  HashTable的子类，唯一和IO流相结合的集合（数据用=或：都可以）
(1)双列集合，单线程，一键一值，K和V默认都是字符串
(2)Properties prop = new Properties();// 建立一个prop集合
(3)Prop.setProperty(K,V);// 向集合中存入元素,取值方法就是getProperty()
（注：setProperties()方法其实此方法改变了prop集合的长度，+1然后又-1，所以遍历prop集合的时候要注意）
(4)Set<String> set = prop.Stringproperties();// 然后遍历
(5)Prop.store(fos,”对此代码的注释，如SAVE Date”);// 数据写入到硬盘，不常用
(6)

(7)Prop.load(fis传入输入流路经);// 获取流中的数据读取到集合中，常用方法
(8)然后遍历
(9)
1、★*缓冲流Buffered，内部自己维护了一个数组(有默认值)，
高效率的原理在于，从硬盘->内存的过程就已经是数组化了,
1)BufferedOutputStream缓冲字节输出流，是输出流的子类，共用方法共享

FileOutputSream fos=new FOS(“aaa.txt”);// 要先建立字节输出流
BufferedOutputSream bos=new BOS(fos); //建立字节缓冲输出流对象,不能直接传入路          径
// 写的时候就已经是写到数组了,所以写得也很快
bos.write(字节); // 传入字节/字节数组，此时存到的是内存中
bos.flush();// 可以省略，此步才把写的数据存到硬盘
bos.close(); // 底层有flush()操作,并且关闭流,不用关闭fos,
2)BufferedInputStream 字节缓冲输入流，使用类似输出流
FileInputStream fis=new FIS(“aaa.txt”);// 建立输入流对象
BufferedIS bis=new BIS(fis); // 建立缓冲输入流对象
Byte[] by=new byte[1024]; // 是用来装内存中的数据到JVM中的，
// 硬盘(缓冲流数组)->内存((bis.read(by))byte数组)/((bis.read())一个一个读)->JVM
// 优化主要是硬盘到内存的效率，因为内存到JVM的速度本来就很快
bis.read(字节/字节数组)；// 读取字节/数组，一个一个读是指内存到jvm
bis.close(); // 关闭流
3)BufferedWriter 字符缓冲输出流
特有成员方法：bw.newLine();// 换行，写入一个行分隔符，根据系统不同，获取不同

操作同FileWriter，
4)BufferedReader 字符缓冲输入流，操作同上
br.readline();// 特有的，返回的是字符串，一次读一行，循环的时候读到最后返回的就是(空)null

2、★*转换流
(1)字符集Charset 编码表，GBK，UTF-8
①乱码就是因为2边默认编码不一致
②FileReader可以读取默认编码格式(UTF-8)的文件
③它读取系统默认编码（中文GBK）会产生乱码
转换流可以自定义读写的编码->读任何编码格式的文件
(2)OutputStreamWriter ：是字符通向字节流的桥梁，可以用指定的Charset将要写入流中的字符编码成字节

1)OutputSW osw=new OSW(new FOS(“a.txt”,”UTF-8”));// 指定以什么(utf-8)格式去编码输出，没有写就默认的是utf-8格式，
2)osw.write(“你好”); // 写入数据
3)osw.flush(); // 刷新数据到文件
4)osw.close();// 关闭流
(3)InputStreamReader 字节流通向字符流的桥梁（硬盘->内存输入(字节->字符)）
1)InputStreamReader isr=new ISR(new FIS(“a.txt”,”utf-8”));// 以什么格式编码去读取什么格式的文件，必须相同，不然就乱码
2)
3)Int len=isr.read(); // 读取文件；
4)Isr.close(); // 关闭流
3、序列化流
序列化和反序列化的时候，会抛出‘没有序列化异常’
要进行序列化和反序列化的类必须实现Serializable接口，并标记，当进行（反）序列化的时候，就会检测是否含有这个标记，有就可以，无则抛异常，而且类的形式改变，这个值就改变，就会报错，可以用Static final来修饰，就会一直不变了。
(1)对象的序列化ObjectOutputStream，把对象以流的方式写到文件中保存

1)ObjectOutputStream oos=new OOS(new FOS(“a.txt”));
2)oos.writeObject(new 对象(属性));// 特有方法，写对象的
3)oos.close(); // 关闭流
(2)对象的反序列化，ObjectInputStream把文件中保存的对象，以流的方式读取出来，也叫做读对象

1)ObjectInputStream ois=new OIS(new Fis(“a.txt”));
2)Object 0=ois.readObject();// 用Object来接收类对象

3)Ois.close();
4)Sout(o);
5)对象 对象名=new 对象();
Sout(对象名(重写了toString()方法的));
4、transient 关键字 瞬态关键字
5、打印流 PrintStream
(1)只负责数据的输出，不负责数据的读取
(2)永远不会抛出IOException
(3)特有方法，print() ,println()（带有换行）,输出任意类型的值

1、函数式编程：强调做什么，而不是以什么形式做
2、New thread( (可带参数)->{方法体sout(直接打印的信息);});
3、Lambda只有函数式接口可以使用，替换内部类，只有一个抽象方法的
4、Lambda的表达式标准格式
(1)一些参数（列表中的数据类型可以省略不写，如果只有一个参数，类型和（）都可以省略）
(2)一个箭头
(3)一段代码，// 只有一行代码的时候，{}和;都可以省略，而且无论是否有返回值都可以省略{}，return，分号，但是要省略就一起省略
(4)（参数列表）->{一些重写方法的代码}
①（）接口中抽象方法的参数列表，没有就空着，多个参数，隔开
②->把参数传递给后面方法体
③{}重写接口的抽象方法的方法体
5、lambda的使用前提：
(1)函数式接口
(2)必须可以推导出来
6、线程池
(1)线程池是一个容纳多个线程的容器，可反复使用，省区了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源
(2)提高相应的速度
(3)提高了线程的可管理性
7、线程池的代码操作
(1)ExecutorService a=Executors.newFixedThreadPool(nThreads:5);
a.submit(线程接口new Rannable(){重写run()方法});// 增加一个线程，并开启，用完了之后放回到线程池
a.shutdown();// 销毁线程池，后面再次调用线程池线程将报错
1、与系统有关的分隔符
(1)String S=File.pathSeparator;// 在Windows系统结果是 ; 而Linux系统则是:
(2)String s=File.separator;// winodws中是\，而Linux中是/，故为了都能用所以格式
用的是C:\der\wfgr\a.txt
转变为”C:”+File.separator+”der”+File.separator+”wfgr”+File.separator+”a.txt”格式
2、”\”转义符，因为双引号或者反斜杠在代码中被看作是字符，所以需要打印直接输入的时候需要转义符，例如sout( “D:\\asd\\as\\a.txt”);//输出结果为 D:\asd\as\a.txt
3、绝对路径：以盘符开始的路径，如：C:\\ad\\asdaf\\a.txt;
4、相对路径：一个简化的路径，相对指相当于当前项目的根目录，
如：C:\\ad\\asdaf\\a.txt，相对的时候->  a.txt;
5、File的方法
(1)File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);// 不考虑路径真假情况，只是把字符转封装为File对象，重写了toString()方法，相对，绝对路径都可以存
(2)File fi=new File(“C:\\aef\\efsg”,”asd\\ss\\x\\z.txt”);// 输出结果为字符串的拼接
参数为父路径和子路径，使用灵活，都可以变化
(3)File fi2=new File(fi,”ada\\a\\z.txt”); // 输出还是为fi路径与字符串的拼接，这样父路径可以单独写
(4)File fi=new File(“\\efsg\\z.txt”);
①fi.getAbsolutePath();// 获取当前对象的绝对路径C:\aef\efsg\z.txt
②fi.getPath();// 获取当前file对象构造中传入的路径 efsg\z.txt
③fi.fetName();// 获取当前文件的名称 z.txt
④long length=fi.length(); // 当前文件的大小 0
// 文件夹没有大小，只有文件才有大小。
6、File类判断方法
File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);
(1)Boolean b=fi.exists(); // 判断该路径是否真实存在，真true假false，相对与绝对路径都可以判断
(2)Boolean b2=fi.isDirectory();// 判断给的路径是否以文件夹结尾
(3)Boolean b3=fi.isFile(); // 判断给的路径是否以文件结尾，与上面是互斥的，
因为电脑硬盘中只有文件或者文件夹，使用前提，路径存在
7、File类创建与删除方法
File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);
(1)Boolean b=fi.createNewFile(); // true文件不存在，fi传递的文件a.txt创建成功，false则表示文件已存在，不会创建，此方法只能创建文件 ，不能创建文件夹，但是创建的文件路径必须存在，否则报错
File fi=new File(“C:\\aef\\efsg”);
(2)Boolean b=fi.mkdir();// 创建单级文件夹,不存在则建，存在则false
File fi=new File(“C:\\aef\\efs\\111\\222\\333”)
(3)Boolean b=fi.mkdirs();// 创建多级文件夹，也可以创建单级的
(4)Boolean b=fi.delet();// 删除文件/文件夹，但是文件夹里面有文件时，文件夹不能直接删除，会输出false，必须先删除文件，并且此删除不走回收站，硬盘中直接删除，谨慎



8、File文件夹的目录的遍历
(1)格式1：File fi=new File(“C:\\aef\\efsg”);// 会先判断文件夹存不存在，如果不存在会包异常，可以再次判断是否为文件夹，fi.isDirectory();
String [] arr1=fi.list(); // 返回的是String数组，元素是第一层的文件夹/文件名字
for(File f1:arr1){
sout(fi);// 直接打印绝对路径，
}
(2)格式2：File fi=new File(“C:\\aef\\efsg”);// 先判断是否为文件夹，fi.isDirectory();
File [] f2 = fi.listFiles();// 返回文件数组，存的是文件// 文件从硬盘存到内存中
For(File f:f2){
Sout(f);// fi.getName();就是打印文件(夹)名,隐藏文件都可以打印
// 在遍历中可以删除文件，不报并发异常，因为删除文件不影响数组长度变化，删除的是硬盘上的文件，数组中的是存在内存中的。
}
9、递归，当前方法内调用自己
(1)格式1：直接递归：main()调用a();,a()又调用a()自己;
(2)格式2：间接递归：main()调用a(),a()调用b(),b()又调用a();
使用注意，要保证递归能够停下来，不然会栈内存溢出，构造方法禁止递归，不然会创建无数个对象，而且递归的次数不能过多，否则也可能超出栈内存
10、用递归遍历给出的文件夹
(1)Public class Test01{
P s v m{
File fi=new File(“C:\\aaa\\afD\\xas”); // 给一个文件夹
getAllFile(fi); // 调用遍历方法
}
Public static void getAllFile(File f1){
Sout(fi); // 打印一下该文件夹的名字
File [] f2=f1.listFiles(); // 把给定的文件夹，文件数组化
for(File f:f2){   // 遍历
if(fi.isDirectory){  // 是文件夹则true
getAllFile(fi);  // 是文件夹就再次递归，来遍历此文件夹
} else {
Sout(f); // 不是文件夹，就直接打印，可以f.getName();打印名字
// 如果要获得特定结尾的文件，就需要获取名字，然后小写化（需要的话）f.getName().toLowerCase().endsWith(“\.txt”);指定打印以.txt结尾的文件，
}
}
}
}
// 输出的就是此文件夹之下的所有文件




11、文件过滤器，获得指定结尾的文件，以FileFilter接口实现的，实现类中重写其中的
accept()方法(过滤方法)，其中传入遍历的文件，
Public class GuoLvQi {  
Psvm(){
File dir=new File(“C:\\aaa\\afD\\xas”); // 获取一个文件夹
getAllFile(dir);  // 调用方法
}
Public static void getAllFile(File dir){
File fi=dir.listFiles(new FileFilterimpl()),// listFiles带参数的重载方法，new实现类
For(File f:fi){  // 遍历
If(f.isDirectory()){ // 是否为文件夹
getAllFiles(f); // 递归调用
}else {
Sout(f); // 是文件则直接打印
}
}
}
}
实现类：
Public class fileimpl implement FileFilter{ // 实现FileFilter接口
@override
Public boolean accept(File f){  // 重写accept()方法
If(f.isDirectory()){  
Return true; // 是文件夹返回true
}
Return f.getName().toLowerCase().endsWith(“\.txt”); // 是文件则判断结尾并返
}
}
listFiles它会对构造方法中传递的目录进行遍历，获取文件(夹)封装为File对象，并调用accept方法，且会把遍历得到的每一个File对象，传递给accept方法的参数，然后返回一个布尔值，如果是true，就会把File对象保存到File[] fi中，否则不存。所以过滤器规则就写在accept()方法中
1、IO流：输入输出流，从硬盘(读取到)->内存就是输入，从内存->(写入到)硬盘就是输出。
2、一个字符等于2个字节，一个字节=8个二进制位
图片，视频，音频，都是字节保存的，都用字节流，不用字符流（可能会出错）
3、字节输出流（保存）：OutputStream顶层父类（抽象类），
FileOutputStream（子类）,（往文件中写数据）文件字节输出流
常用方法步骤：
先要创建对象，
FileOutputStream fos=new FileOutputStream(name:”11/aaa.txt”，append:teue);参数：指定路径创建一个文件,但是文件是在关闭流（有fos.close）的时候才创建的，不关流也可以创建。后面加append：true，是续写，不会覆盖之前的数据；加append：false，指创建一个新的文件，覆盖原文件
new FileOutputStream可以默认创建一个文件
(1)fos.write(int a);// 写入一个字节，数据写入文件
(2)fos.write(byte[] bytes);//写入一个字节数组
可用(String类型) str.getBytes();字符串转字节数组
如果写的第一个字节是负数，第一和第二字节会组成一个中文显示，2字节=1中文
(3)fos.write(bytes,int off,int len);// 写入字节数组中的一部分，bytes是数组，off是数组起始的索引值，len是写入几个字节（数据的长度）
(4)fos.close();// 写入完毕必须要关闭流，清空->为了释放资源，因为流会占用内存，
如果不用fos.write()写入数据直接创建，此空文件就会覆盖同名文件，但是有append的时候就只是没有新的数据续写而已，文件不会被覆盖为空
(5)写换行，windows格式:fos.write( “\r\n”.getBytes()); //跳到下一行开头  linux:/n   mac:/r
4、字节输入流：FileInputStream,把硬盘中的数据读取到内存中使用
常用方法使用步骤：
(1)创建FileInputStream对象，绑定要读取的数据源
①FileInputStream fis=new FileInputStream(“a.txt”);// 读取数据源
(2)Int a1=fis.read();// 返回的是一个字节，读取到文件的末尾(没有元素了)返回-1；读取的时候，取完元素后，指针会向后移动一位，                                                                              因为是重复，可用while循环
①Int len=0;// 需要变量，否则容易漏读等，read()一次就读写一次，故此谨慎
②While ((len=fis.read())!=-1){ // 读取一个字节，赋值给变量，判断=-1否，并且指针指向下一个字节，
Sout((char)len);// int转换为字符输出
}
3)Byte [] bytes=new byte[1024];// 定义一个字节数组，读取多个字节，起到了缓冲的作用，数组长度可以小于要读取的文件字节总数，fis.read(bytes);小于的时候就是长度为几，就先读取几个，后面再继续，通常定义1024个字节或其整数倍
本质也是一个一个的读，先从硬盘(一个一个)到内存(字节数组)，再从内存(数组)到JVM(数组)，提高的效率在于从内存到JVM的过程
4)Int len = fis.read(bytes); // 读取文件的字节，并保存到字节数组中，len接收返回的读取的字节个数，
5)Sout(len);
6)Sout(new String(bytes,0,len));// 读取的字节数组字符串化，从索引0开始，输出        len个字符(减去索引值起始位置之后，不能超出数组的长度)
读取可以用while循环，直到读完。(读取中文的时候容易出错)
(3)fis.close();// 同理关流。
5、字符输入流：Reader抽象类，用其子类FileReader文件字符输入流，
主要用来输入中文，常用方法，步骤
(1)FileReader fr=new FileReader(文件路径); // 建一个对象
(2)Char[] ch=new char[1024]; // 建一个char数组
(3)Int len=0; // 变量来接收读取的字符个数
(4)While((len=fr.read(ch))!=-1){ // 判断读取的字符个数=-1否，数组到最后取完字符的时候，下一次会跳到结束指令符，直接返回-1，而不是取到的字符长度
Sout(new String(ch,0,len)); // 以字符串的形式输出
Sout((char)len);// 或者直接以字符输出，一个一个读的时候用
}
fr.close(); // 关闭流
6、字符输出流：FileWrite extends OutputSream类
(1)FileWrite fw=new FileWrite (写入数据目的地文件路径);
(2)fw.write(); // 写入字符
(3)fw.write(“xfezfes”);// 字符串可以直接写入字符
(4)fw.flush();// 把内存缓冲区的数据，刷新到文件中，输出流都有该方法，而输入流没有，刷新后流还可以继续使用，
(5)fw.close();// 把内存缓冲区的数据，刷新到文件中，并且关闭流
7、Properties  HashTable的子类，唯一和IO流相结合的集合（数据用=或：都可以）
(1)双列集合，单线程，一键一值，K和V默认都是字符串
(2)Properties prop = new Properties();// 建立一个prop集合
(3)Prop.setProperty(K,V);// 向集合中存入元素,取值方法就是getProperty()
（注：setProperties()方法其实此方法改变了prop集合的长度，+1然后又-1，所以遍历prop集合的时候要注意）
(4)Set<String> set = prop.Stringproperties();// 然后遍历
(5)Prop.store(fos,”对此代码的注释，如SAVE Date”);// 数据写入到硬盘，不常用
(6)

(7)Prop.load(fis传入输入流路经);// 获取流中的数据读取到集合中，常用方法
(8)然后遍历
(9)
1、★*缓冲流Buffered，内部自己维护了一个数组(有默认值)，
高效率的原理在于，从硬盘->内存的过程就已经是数组化了,
1)BufferedOutputStream缓冲字节输出流，是输出流的子类，共用方法共享

FileOutputSream fos=new FOS(“aaa.txt”);// 要先建立字节输出流
BufferedOutputSream bos=new BOS(fos); //建立字节缓冲输出流对象,不能直接传入路          径
// 写的时候就已经是写到数组了,所以写得也很快
bos.write(字节); // 传入字节/字节数组，此时存到的是内存中
bos.flush();// 可以省略，此步才把写的数据存到硬盘
bos.close(); // 底层有flush()操作,并且关闭流,不用关闭fos,
2)BufferedInputStream 字节缓冲输入流，使用类似输出流
FileInputStream fis=new FIS(“aaa.txt”);// 建立输入流对象
BufferedIS bis=new BIS(fis); // 建立缓冲输入流对象
Byte[] by=new byte[1024]; // 是用来装内存中的数据到JVM中的，
// 硬盘(缓冲流数组)->内存((bis.read(by))byte数组)/((bis.read())一个一个读)->JVM
// 优化主要是硬盘到内存的效率，因为内存到JVM的速度本来就很快
bis.read(字节/字节数组)；// 读取字节/数组，一个一个读是指内存到jvm
bis.close(); // 关闭流
3)BufferedWriter 字符缓冲输出流
特有成员方法：bw.newLine();// 换行，写入一个行分隔符，根据系统不同，获取不同

操作同FileWriter，
4)BufferedReader 字符缓冲输入流，操作同上
br.readline();// 特有的，返回的是字符串，一次读一行，循环的时候读到最后返回的就是(空)null

2、★*转换流
(1)字符集Charset 编码表，GBK，UTF-8
①乱码就是因为2边默认编码不一致
②FileReader可以读取默认编码格式(UTF-8)的文件
③它读取系统默认编码（中文GBK）会产生乱码
转换流可以自定义读写的编码->读任何编码格式的文件
(2)OutputStreamWriter ：是字符通向字节流的桥梁，可以用指定的Charset将要写入流中的字符编码成字节

1)OutputSW osw=new OSW(new FOS(“a.txt”,”UTF-8”));// 指定以什么(utf-8)格式去编码输出，没有写就默认的是utf-8格式，
2)osw.write(“你好”); // 写入数据
3)osw.flush(); // 刷新数据到文件
4)osw.close();// 关闭流
(3)InputStreamReader 字节流通向字符流的桥梁（硬盘->内存输入(字节->字符)）
1)InputStreamReader isr=new ISR(new FIS(“a.txt”,”utf-8”));// 以什么格式编码去读取什么格式的文件，必须相同，不然就乱码
2)
3)Int len=isr.read(); // 读取文件；
4)Isr.close(); // 关闭流
3、序列化流
序列化和反序列化的时候，会抛出‘没有序列化异常’
要进行序列化和反序列化的类必须实现Serializable接口，并标记，当进行（反）序列化的时候，就会检测是否含有这个标记，有就可以，无则抛异常，而且类的形式改变，这个值就改变，就会报错，可以用Static final来修饰，就会一直不变了。
(1)对象的序列化ObjectOutputStream，把对象以流的方式写到文件中保存

1)ObjectOutputStream oos=new OOS(new FOS(“a.txt”));
2)oos.writeObject(new 对象(属性));// 特有方法，写对象的
3)oos.close(); // 关闭流
(2)对象的反序列化，ObjectInputStream把文件中保存的对象，以流的方式读取出来，也叫做读对象

1)ObjectInputStream ois=new OIS(new Fis(“a.txt”));
2)Object 0=ois.readObject();// 用Object来接收类对象

3)Ois.close();
4)Sout(o);
5)对象 对象名=new 对象();
Sout(对象名(重写了toString()方法的));
4、transient 关键字 瞬态关键字
5、打印流 PrintStream
(1)只负责数据的输出，不负责数据的读取
(2)永远不会抛出IOException
(3)特有方法，print() ,println()（带有换行）,输出任意类型的值