线程池：
在多线程的使用过程中，会存在一个问题：如果并发的线程数量很多，并且每个线程都执行一个时间很短的任务就结束，这样频繁的创建线程就会大大降低系统的效率，因为线程的创建和销毁都需要时间。
线程池： 为了解决上面频繁的创建和销毁线程的问题，在java中可以通过线程池来达到线程复用的场景，也就是一个线程在执行完一个任务后，不会被销毁，而是继续执行其他的任务。线程池实际就是一个容纳线程的容器，省去了频繁创建线程对象的操作，节约了很多资源。
线程池执行原理：
线程池的使用：
设置线程任务：
public class RunnableImpl implements Runnable {
@Override
public void run(){
System.out.println("线程：" + Thread.currentThread().getName());
};
}
使用过程：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// java.util.concurrent.Executors:线程池的工厂类，用来生成线程池，其中有一个方法用来生成一个指定线程数的线程池：newFixedThreadPool(int n)
// 线程池的使用步骤：
// 1.使用线程池的工厂类：Executors里的静态方法newFixedThreadPool创建一个指定线程的线程池
// 2.创建一个类，实现Runnable接口，重写run方法设置线程任务
// 3.调用ExecutorService中的submit方法，传递线程任务（刚刚创建的实现类）开启线程
// 4.调用ExecutorService中的shutdown销毁线程池（不建议使用，只有线程池不需要的时候才会用到该方法）
public class ThreadPool {
public static void main(String[] args) {
// 获取线程池：
ExecutorService es = Executors.newFixedThreadPool(2); // 指定线程池数量
// 执行线程任务：线程池会一直开着，使用完了线程，会自动把线程归还给线程池，线程可以继续执行
es.submit(new RunnableImpl()); // 线程：pool-1-thread-1
// es.shutdown(); // 执行此代码关闭线程池，后面代码在执行会抛异常
es.submit(new RunnableImpl()); // 线程：pool-1-thread-2
es.submit(new RunnableImpl()); // 线程：pool-1-thread-1，第一次使用完后会归还给线程池继续被使用
}
Lambda表达式：
Lambda表达为了解决冗余代码问题的，从创建一个多线程任务的案例来看，为了执行run任务，是不断的调用对象的方法，此过程为面向对象编程，为了执行一个run任务（打印一句话）发现写了很多无关的代码，但是这些代码在面向编程中又不能没有，此时为了简化代码书写减少代码冗余，可以采用函数式编程，函数式编程是一个只注重结果，不注重是谁完成了这个事，Lambda就是函数式编程思想。
Lambda表达式由三部分组成：一些参数、一个箭头、一段代码
import java.util.Arrays;
import java.util.Comparator;
public class LambdaTest {
public static void main(String[] args){
// 1.测试lambda表达式：
// 使用匿名内部类创建一个线程任务：
new Thread(new Runnable(){
@Override
public void run(){
System.out.println("执行任务!");
};
}).start();
// 使用Lambda创建一个线程任务：
new Thread(()->{
System.out.println("执行Lambda任务!");
}).start();
// Lambda更优写法：其中括号为run方法的参数，可以接收前面需要传递的参数，箭头表示将参数传递给后面，箭头后面的语句为业务逻辑代码
new Thread(()->System.out.println("执行Lambda任务2!")).start();
// 2.调用useSayHayInterFace方法：
useSayHayInterFace(new SayHay(){
@Override
public void sayhello(){
System.out.println("重写sayhello方法");
};
});
// 3.使用lambda表达式调用useSayHayInterFace方法：
useSayHayInterFace(()->System.out.println("重写sayhello方法2"));
// 4.使用lambda表达式联系一个数组中存储多个person对象，并对其以年龄进行排序：
Person[] list = { new Person("小明",18), new Person("小红",20),new Person("小美",10) };
Arrays.sort(list, new Comparator<Person>(){
@Override
public int compare(Person a,Person b){
return a.getAge() - b.getAge();
};
});
for (Person p : list) {
System.out.println(p);
};
System.out.println("----------------------------");
// 使用lambda表达式简化：
Arrays.sort(list, (Person a,Person b)->{
return b.getAge() - a.getAge();
});
for (Person p : list) {
System.out.println(p);
};
};
// 定义一个方法使用接口：
public static void useSayHayInterFace(SayHay s){
s.sayhello();
};
}
file类：
file类是文件和目录路径名的抽象表示，主要用于文件和目录的创建和查找及删除等操作。
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Objects;
public class FileDemo {
// 1.file类可以创建一个文件或文件夹、删除一个文件或文件夹、获取一个文件或文件夹
// 2.file类与操作系统无关，任何操作系统都可以使用此类
public static void main(String[] args) throws IOException {
// 3.File类的pathSeparator属性用来获取路径分隔符
String pathSeparator = File.pathSeparator;
System.out.println(pathSeparator); // 打印了一个封号，windows分隔符是一个分号，linux会打印一个冒号
// 4.File类的separator属性用来获取文件名分隔符：
String separator = File.separator;
System.out.println(separator); // 打印了一个反斜杠，windows返回一个反斜杠，linux返回一个正斜杠
// 5.路径：分绝对路径和相对路径，相对路径是相对于当前项目的根目录，绝对路径是相对于盘符开始的，路径不区分大小写，windows中文件名分隔符为反斜杠，需要写两个反斜杠进行转义。
// 6.File类的构造方法：此构造方法传入一个路径，用来创建一个新的File实例，这个路径可以是以文件名结尾，也可以以文件夹结尾,也可以是一个不存在的路径
File fs = new File("D:\\00.java高级\\练习\\javaDemo\\073file类");
System.out.println(fs); // D:\00.java高级\练习\javaDemo\073file类
// file类的构造方法也可以传递两个参数：第一个父路径，第二个为子路径：实际就是将两个路径进行拼接在一起：
File fs2 = new File("c://","a.text");
System.out.println(fs2); // c:\a.text
// file类的第一个参数父路径也可以传入一个file类：
File fs3 = new File(fs, "b.text"); // 这里的父类路径后面可以调用它的方法得到想要的值：
System.out.println(fs3); // D:\00.java高级\练习\javaDemo\073file类\b.text
// 7.getAbsoluteFile()方法用来获取File类的绝对路径，String.valueOf是这个java版本中结局报错的
File fs4 = new File("ab.text");
String p3 = String.valueOf(fs4.getAbsoluteFile());
System.out.println(p3); // D:\00.java高级\练习\javaDemo\073file类\ab.text
// 8.getPath方法获取File类的真实路径，传递的什么，返回的就是什么：
File fs5 = new File("D://files//hello.text");
String p5 = fs5.getPath();
System.out.println(p5); // D:\files\hello.text
File fs6 = new File("hello.text");
String p6 = fs6.getPath();
System.out.println(p6); // hello.text
// 9.getName方法获取File类的结尾部分，可以是一个文件夹或文件名：
String fsname = fs.getName();
System.out.println(fsname); // 073file类
String fileName = fs5.getName();
System.out.println(fileName); // hello.text
// 10.length获取文件的大小，以字节为单位：如果路径不存在，则返回0,文件夹返回的也是0
File fslength = new File("D:\\00.java高级\\练习\\javaDemo\\073file类\\FileDemo.java");
Number sizes = fslength.length();
System.out.println(sizes); // 3261
// 11.exists方法用来判断File表示的文件或路径是否存在：
File isExist = new File("hello.java");
System.out.println(isExist.exists()); // false
// 12.isDirectory判断给定的路径是否以文件夹结尾，isFile判断给定的目录是否以文件结尾：(特别提示：这个两个方法都是建立在路径真实存在的情况下，如果不存在则都表示false)
System.out.println(fs.isDirectory()); // true
System.out.println(fs.isFile()); // false
System.out.println(isExist.isFile()); // false
System.out.println(isExist.isDirectory()); // false
System.out.println(fslength.isFile()); // true
System.out.println(fslength.isDirectory()); // false
// 13.createNewFile()方法用来创建文件，如果File类没有此文件就去创建文件并返回一个true,如果已存在文件再去创建，会返回false;创建文件的路径必须存在，否则会抛出异常：
File ft = new File("D:\\00.java高级\\练习\\javaDemo\\073file类\\hello.text"); // 路径是相对或绝对都可以
boolean file1 = ft.createNewFile(); // 此方法或抛出异常，可以使用try/cathc或直接抛出给虚拟机处理
System.out.println(file1); // true,第一次执行返回一个true并生成一个hello.text文件，再次执行代码就返回false,因为已经存在了此文件
// 14.mkdir和mkdirs用来创建文件夹，mkdir用来创建单级文件夹，mkdirs用来创建多级文件夹，它们创建的都是空文件夹，如果原本文件夹不存在去创建返回true,原本文件夹存在或路径不存在都返回false,它们只能创建文件夹，不能创建文件，绝对和相对路径都支持，路径不存在不会抛异常：
File fp = new File("D:\\00.java高级\\练习\\javaDemo\\073file类\\newfile1");
boolean isOk = fp.mkdir();
System.out.println(isOk); // true,也是第一次返回true,再次执行返回false
File fm = new File("D:\\00.java高级\\练习\\javaDemo\\073file类\\newfile2\\001\\01\\1");
boolean isOkMor = fm.mkdirs(); // 创建多级文件夹
System.out.println(isOkMor); // true,也是第一次返回true,再次执行返回false
// 15.delete方法可以删除文件或文件夹，文件或文件夹删除成功返回true,文件夹中有内容时不会被删除返回false,构造方法中的路径不存在时也返回false(在硬盘中删除，不走回收站)
File rm = new File("D:\\00.java高级\\练习\\javaDemo\\073file类\\hello.text");
boolean isRm = rm.delete();
System.out.println(isRm); // true
File rm2 = new File("D:\\00.java高级\\练习\\javaDemo\\073file类\\newfile2\\001\\01\\1");
boolean isRm2 = rm2.delete();
System.out.println(isRm2); // true,这里删除的1这个文件夹，需要注意！
// 16.list和listFiles方法用来遍历目录，list返回一个字符串数组，表示该文件夹中所有子文件或子文件夹;listFiles返回的是一个文件类型数组，如果构造方法中的路径不存在，会抛出异常，如果构造方法中的路径不是一个目录，也会抛出异常
File fslist = new File("D:\\00.java高级\\练习\\javaDemo\\073file类");
String[] ls = fslist.list();
System.out.println(Arrays.toString(ls));
System.out.println("-----1------");
for (String s : Objects.requireNonNull(ls)) {
System.out.println(s);
}
File[] flist = fslist.listFiles();
System.out.println(Arrays.toString(flist));
System.out.println("-----2------");
for (File f : Objects.requireNonNull(flist)) {
System.out.println(f);
}
}
}
递归：
java中递归是指方法的自调用，递归可分为直接递归（直接调佣自己）和间接递归（在a方法中调用b方法，b方法中又调用了a方法）；递归中应该有条件限制和次数不能太多，否则容易导致栈溢出，递归应该有结束条件。
过滤规则：
import java.io.File;
import java.io.FileFilter;
public class FileFilterImpl implements FileFilter {
// 1.实现一个FileFilter接口并重写接口中的accept方法实现过滤规则：
@Override
public boolean accept(File pathname){
// 返回true会放过这个值，返回false会过滤掉：
if (pathname.isDirectory()) {
// 如果是文件夹也返回true继续遍历
return true;
}
return pathname.getName().toLowerCase().endsWith(".java");
};
}
递归测试：
import java.io.File;
import java.util.Objects;
public class ForMethods {
public static void main(String[] args){
// 1.实现递归：
int num = 0;
count(num);
// 2.过滤器：listFiles方法有两个重载形式，里面传入一个FileFilter接口的实习类对象可对目录项进行过滤：
File fslist = new File("D:\\00.java高级\\练习\\javaDemo\\074.递归");
// 传入FileFilter接口的实现类对象进行过滤数据
File[] flist = fslist.listFiles(new FileFilterImpl());
for (File f : Objects.requireNonNull(flist)) {
// System.out.println(f);
}
// 3.过滤器找到所有的java结尾的文件：
File fs = new File("D:\\00.java高级\\练习\\javaDemo\\074.递归");
getAllFile(fs);
}
public static void count(int i){
if (i > 10) { // 结束条件，递归的次数不能太多，否则会有栈溢出
return;
} else {
// System.out.println(i);
i++; // 改变条件变量
count(i);
}
};
//3.递归的方式打印出以java结尾的文件：
public static void getAllFile(File dir){
File[] files = dir.listFiles(new FileFilterImpl());
for (File f : Objects.requireNonNull(files)) {
// 如果是目录则继续递归遍历，否则打印文件名
if (f.isDirectory()) {
getAllFile(f);
System.out.println("继续递归：" + f);
} else {
System.out.println(f);
}
}
};
}
提示：本文图片等素材来源于网络，若有侵权，请发邮件至邮箱：810665436@qq.com联系笔者删除。
笔者：苦海
