1、lambda 表达式
lambda 的延迟执行
可以对程序进行优化，尤其是使用 if {} else {} 条件判断，先判断条件是否成立，再传入计算好的参数。
functionName( paramters, () -> { } );
2、stream 流式思想
stream 是jdk8之后出现的语法
拼接流式模型：建立一个生产线，按照生产线来生产商品
经过了过滤、映射、跳过、计数等多步操作，集合元素的处理方案
filter、map、skip，得益于lambda的延迟执行特性。
（1） 获取流
数据源流的来源：集合、数组
java.util.stream.Stream
// 所有的Collention 集合 ( list, map, set.. )都可以通过stream默认方法获取流 ArrayListarrStr = new ArrayList(); stream // Stream接口的静态方法 of 可以获取数组对应的流 Streamstream1 = arrStr.stream(); Stream2 = Stream.of(1, 4, 3, 5, 5);
// Stream 流只能使用一次，使用完之后就直接关闭了。即
Streamstream3 = Stream.of("1", "2", "9", "4");
stream3.forEach((String str)-> { System.out.println(str); }); // 再重新打印一次，输出异常 stream3.forEach((String str)-> { System.out.println(str); });
（2）取用前几个：limit 如果当前长度大于参数进行截取，否则不截取。limit 是一个延迟方法，返回的是一个新的流
Stream stream4 = stream3.limit(2);
stream4.forEach( str -> System.out.println(str) );
（3）跳过前几个：skip 与 limit 相反
（4）流拼接： concat
java 泛型
java泛型不允许静态化，类中含有 static 会报错：
// 分类：
// 1、泛型类
public class 类名 {
}
// 2、泛型接口
public interface Generator {
}
// 3、泛型方法
类型通配符 ?
区别：
该通配符所代表的类型是T类型的子类
该通配符所代表的类型是T类型的父类
反射提供的是runtime阶段获取类的class 实例、方法、属性、注解， 并且能够调用勒的方法的途径。
java 多线程
PS：查阅了相关资料和视频，这种类似于计算机内核原理的知识，建议翻阅教科书，了解一下什么是堆，栈，缓冲区等计算机专属词汇，网上很多人讲的不严谨，如果有人想深入大体了解内部机制，强烈安利这个教程 计算机系统基础，有好几季，课程比较长，虽然比较难
并行：指两个或多个事件在同一时刻运行（同时运行）。
并发：指两个或多个事件在同一个时间间隔内发生。
线程与进程两者的关系图，推荐看这个图，比较严谨：
https://blog.csdn.net/weixin_41490593/article/details/90704559
多线程编程：
Java中线程有四种创建方式：
l 继承Thread类
l 实现Runnable接口
l 实现Callable接口
l 线程池
前三种方法相应的资料很多，这里仅仅粗略赘述线程池：
/* java.util.concurrent.ExecutorService 线程池接口 线程池：容器 -- > 集合框架( ArrayList, HashSet, LinkedList, HashMap ) 接口： static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池 ExecutorService 接口，返回的是ExecutorService接口的实现类对象，可用ExecutorService接口接收（面向接口编程） submit() 执行线程 线程池会一直开启，使用完了线程，会自动吧线程归还给线程池，线程可以继续执行。 shutdown() 关闭执行， 如果已经执行了此方法，如果重新 使用 submit 方法， 会报错 。 线程池的使用步骤： 1、使用线程池的工厂类 Executors 里面提供的 newFixedThreadPool 生产一个指定线程池数量的线程池 2、创建一个类，实现 Runnable 接口，重写 run 方法，设置线程任务 3、调用ExecutorService 中的方法 submit ，传递线程任务（实现类）， 开启线程， 执行 run 方法 4、调用ExecutorService 中的方法 shutdown ，销毁线程池 */
进程间协作：
wait ： 是object 类中的一个方法，当前线程释放自己的锁标记，让出CPU资源，当前的线程进入到等待队列中
notify： 是object 类中的一个方法，唤醒等待队列中的一个进程，使这个线程进入锁池
notifyAll ： 唤醒等待队列中的等待当前对象的所有线程，并使这些线程进入锁池
java线程同步机制：
锁，通俗地讲就是告诉其他的线程，这里的鱼塘我承包了，等我解锁你再用
同步锁： 多个线程看到的锁， 需要是同一把锁。
静态方法：同步锁就是类锁， 当前类.class 属性 --> class 文件对象，这一点涉及到 java反射，静态方法优先于对象。
非静态方法： 同步锁 是 this，this 是在创建对象之后产生的。
Runnable r = () -> {
while(TicketCenter.restCount > 0 ) {
// synchronized ("") {
synchronized (Generic.class) {
if (TicketCenter.restCount <= 0) {
return ;
}
System.out.println("当前运行的进程 ： " + Thread.currentThread().getName() + " " + --Center.restCount);
}
}
};
Thread t1 = new Thread(r, "thread - 1");
Thread t2 = new Thread(r, "thread - 2");
Thread t3 = new Thread(r, "thread - 3");
Thread t4 = new Thread(r, "thread - 4");
t1.start();
t2.start();
t3.start();
t4.start();
class Center {
public static int restCount = 100;
}
// 如果一个方法需要执行同步操作，直接加入 synchronize 关键字
// 同步方法
private synchronized static void funControl() {
// synchronized (Generic.class) {
if (TicketCenter.restCount <= 0) {
return ;
}
System.out.println("当前运行的进程 ： " + Thread.currentThread().getName() + " " + --TicketCenter.restCount);
// }
}
显式锁 : ReentrantLock 重入锁
当接触临界区时 ReentrantLock 是在 Lock 接口实现的。临界资源由 lock() 和 unlock() 组成。lock() 就是让当前工作进程进入资源，然后使其他的试图进入临界资源的进程阻塞。
ReentrantLock 能够让进程不止一次的进入资源。当这个进程第一次进入内存的时候，有一个计数器记为1，在解锁之前，一个进程又进入时，计数器递增1，每一次unlock() 时，计数器递减1。当计数器为0时，资源被解锁。
Reentrant Locks 可重入锁还提供一个公平性参数，通过该参数，锁将遵守锁请求的顺序，即在线程解锁资源后，锁将转到等待时间最长的线程。此公平模式是通过将true传递给锁的构造函数来设置的。
/*
* 实例化一个锁对象
*/
ReentrantLock lock = new ReentrantLock();
Runnable r = () -> {
while(TicketCenter.restCount > 0 ) {
// 临界资源上锁
lock.lock();
if (TicketCenter.restCount <= 0) {
return ;
}
System.out.println("当前运行的进程 ： " + Thread.currentThread().getName());
// 解锁
lock.unlock();
}
};
public void some_method()
{
reentrantlock.lock();
try
{
//Do some work
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
reentrantlock.unlock();
}
}
// volatile关键字 以及 CAS与原子变量使用的不多，这里就不再赘述了。