继承
封装
多态
==的比较地址是否相等
equals在不重写的情况下，底层调用的就是==去比较地址
在重写只会则是比较类中的数据是否相同
重写了hashcode方法之后，一定要重写equals，
因为hashcode的长度是固定的，当数据足够多时，便会出现数据不相同而，hashcode相同的情况
此时便需要使用equals判断
不一样，因为内存的分配方式不一样。
String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中。
如果整型字面量的值在-128到127之间，那么自动装箱时不会new新的Integer对象，而是直接引用常量池中的Integer对象，超过范围 a1==b1的结果是false
Integer a = new Integer(3);
Integer b = 3; // 将3自动装箱成Integer类型
int c = 3;
System.out.println(a == b); // false 两个引用没有引用同一对象
System.out.println(a == c); // true a自动拆箱成int类型再和c比较
System.out.println(b == c); // true
Integer a1 = 128;
Integer b1 = 128;
System.out.println(a1 == b1); // false
Integer a2 = 127;
Integer b2 = 127;
System.out.println(a2 == b2); // true
重载：发生在一个类中，方法名必须相同，参数的类型不同、个数不同、顺序不同
重写：
final作用于类：该类无法被继承
final作用与方法：该方法无法被重写，但能被继承
final作用于属性：
静态代码块：在虚拟机加载类的时候就会加载执行，而且只执行一次
构造代码块：每次创建对象的时候便会执行一次
执行顺序：（优先级从高到低。）静态代码块>mian方法>构造代码块>构造方法。
int、long、short、float、double、byte、boolean、char
String底层是不可变的char数组，每一次修改都是在new一个新的string对象
而StringBuilder和StringBuffer是可变的char数组
StringBuilder是线程不安全的，性能高
StringBuffer是线程安全的，性能较低
基本数据类型存放在栈中，包装类型存储在堆中
（反射）是被视为动态语言的关键
//方式1 通过运行时类的属性
Class<User> userClass=User.class;
Class s = String.class;
//方式2 通过运行时类的对象，调用 getClass方法
User u=new User();
Class userClass2=u.getClass();
//方式3 通过forName静态方法
Class c1= Class.forName("java.lang.String");
Class userClass3 = Class.forName("com.jie.pojo.User");
//方式4 使用类的加载器 （了解即可）
ClassLoader classLoader=reflectionTest.class.getClassLoader();
Class userClass4=classLoader.loadClass("com.jie.pojo.User");
System.out.println(userClass4);
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YIfbRfOE-1620218177125)(img\8.png)]](https://img-blog.csdnimg.cn/20210505203725437.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hdGVfMTgxNjMxMjY=,size_16,color_FFFFFF,t_70#pic_center)
HashSet的底层就是 实例了HashMap对象
在添加时，将数据放在Map的key位置，value则是空object对象
TreeSet同样是实例了TreeMap
TreeMap底层是自平衡二叉树，实现了key按大小排列
hashTable部分代码
/*
map.put(k,v)实现原理
1. 先将k,v封装到Node对象中
2. 底层会调用k的hashCode()方法得到hash值，然后通过哈希函数/哈希算法，将hash值转换成数组的下标
3. 如果此时的下标位置上没有任何元素，将把Ndoe添加到这个位置上
4. 如果说下标对应的位置上有链表，则判断是否存在key的hash相同，key之间的equals比较为true的节点
5. 存在则替换该节点，不存在则在节点末尾添加
*/
public synchronized V put(K key, V value) {
// 判断value是否为空
if (value == null) {
throw new NullPointerException();
}
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length; //通过hash确定下标
Entry<K,V> entry = (Entry<K,V>)tab[index]; //获取该下标的链表
for(; entry != null ; entry = entry.next) {
//如果该链表中有hash相同，并且key的equals也为true 则替换节点
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
//否则添加到链表的末尾
addEntry(hash, key, value, index);
return null;
}
/*
map.get(k)实现原理
1. 先调用k的hashCode()方法得出hash值，通过哈希算法将该哈希值转换为数组下标，通过数组下标快速定位到指定位置，如果这个位置是什么也没有，就返回null
2. 如果此时这个位置上有单向链表，则判断此链表上是否存在key的hash相同且equals为true的节点
3. 有则返回其value 否则返回null
*/
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length; //通过hash值确定数组下标
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) { //如果两个条件则输出该value
return (V)e.value;
}
}
return null; //否则返回null
}
map.put(k,v)实现原理
map.get(k)实现原理
继承与Thread类，重写run方法
实现ruannable接口，实现run方法
实现Callable接口中的call方法
可以抛异常
可以返回值
futureTask.get() //获取返回值 但必须等待该线程执行完毕
可以支持泛型
需要借助FutrueTask工具类来实现
yield(): 释放线程
sleep()：该线程进入堵塞状态 若干毫秒，不会释放锁
join():
interrupt(): 打断线程
setDaemon(true) 守护线程
新建、就绪、运行、堵塞、终止
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jNnWP7uw-1618880935978)(img\3.png)]](https://img-blog.csdnimg.cn/20210420091035784.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hdGVfMTgxNjMxMjY=,size_16,color_FFFFFF,t_70#pic_center)
线程是生命周期要经历五种状态：
setDaemon(true) 守护线程
java进程中有多个线程在执行时，当所有其他非守护线程都执行完毕后，无论守护线程是否执行完毕，也会一同结束线程
synchronized(同步监视器){
需要被同步的代码
}
关于同步方法:
public synchronized void test() {
}
同步方法仍然涉及到同步监视器
同步方法上锁的对象
加在成员方法上 （对象实例本身）
加在静态方法上 （类本身）
死锁
public static void main(String[] args) {
Object a=new Object();
Object b=new Object();
new Thread(() -> {
synchronized (a) {
System.out.println(Thread.currentThread().getName() + "我获取a锁,过会儿去获取b锁");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (b) {
System.out.println(Thread.currentThread().getName() + "我获取了 a 和 b,方法执行结束");
}
}
}).start();
new Thread(() -> {
synchronized (b) {
System.out.println(Thread.currentThread().getName() + "我获取b锁,过会儿去获取b锁");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (a) {
System.out.println(Thread.currentThread().getName() + "我获取了 a 和 b,方法执行结束");
}
}
}).start();
}
解决办法
活锁
活锁出现在两个线程互相改变对方的结束条件，后谁也无法结束。
需要创建一个ReentrantLock对象
通过
基本语法：
//获取ReentrantLock对象
private ReentrantLock lock = new ReentrantLock();
//加锁
lock.lock();
try {
//需要执行的代码
}finally {
//释放锁
lock.unlock();
}
锁超时
使用lock.tryLock方法会返回获取锁是否成功。如果成功则返回true，反之则返回false。
设置等待时间
//判断获取锁是否成功，最多等待1秒
if(!lock.tryLock(1, TimeUnit.SECONDS)) {
System.out.println("获取失败");
//获取失败，不再向下执行，直接返回
return;
}
相同:
不同:
synchronized机制在执行完相应的同步代码以后，自动的释放同步监视
Lock需要手动的启动同步 Lock()，同时结束同步也需要手动的实现 unlock()
synchronized 是Java内置的关键字
Lock是java.util.concurrent.Locks 包下的一个接口
synchronized 是非公平锁，即不能保证等待锁线程的顺序
Lock的实现 ReentrantLock 可通过实例化true or false 的构造参数实现公平锁和非公平锁，默认为非公平锁
synchronized无法判断是否获取锁的状，Lock可以判断是否获取到锁；
Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。
synchronized是一个悲观锁，Lock是一个乐观锁（底层基于volatile和cas实现）
说明:
wait( ),notify()，notifyALl()
三个方法必须使用在同步代码块或同步方法 而且由一个对象锁监控
三个方法的调用者必须是同步代码块或同步方法中的同步监视器 否则，会出现ILLegaLMonitorStateException异常 （必须是一个对象）
相同点:一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点:
两个方法声明的位置不同: Thread类中声明sLeep() , object类中声明wait()
调用的要求不同: sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或者同步方法中
关于是否释放同步监视器:,如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁
park/unpark都是LockSupport类中的方法
//暂停线程运行
LockSupport.park;
//恢复线程运行
LockSupport.unpark(thread);
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
System.out.println("start");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("park");
//该线程 进入暂停
LockSupport.park();
System.out.println("return");
});
thread.start();
Thread.sleep(100);
LockSupport.unpark(thread); //由主线程恢复thread线程的运行
}
区别
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XNSeOpjW-1620217788901)(img\1.png)]](https://img-blog.csdnimg.cn/20210505203012667.png#pic_center)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fblBqz9z-1620217788903)(img\2.png)]](https://img-blog.csdnimg.cn/20210505203021617.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hdGVfMTgxNjMxMjY=,size_16,color_FFFFFF,t_70#pic_center)
当文件中的对象进行反序列化时，会先判断文件中类名和程序中类名是否一致
如果相同则再比较文件中对象的序列号，和项目中类的序列号是否相同
如果不相同则会报异常
java.io.InvalidClassException: com.jie.io.Person;
local class incompatible: stream classdesc serialVersionUID = -7564189118422739644, local class serialVersionUID = -2265004783317520704
为什么会导致文件中类的序列号和项目中类的序列号不同呢？
java.io.InvalidClassException: com.jie.io.Person;
local class incompatible: stream classdesc serialVersionUID = -7564189118422739644,
local class serialVersionUID = -2265004783317520704 //序列号不同
所以需要给可序列的类给定一个固定的序列号，使磁盘和内存中的类的序列号始终相同
](https://nyimapicture.oss-cn-beijing.aliyuncs.com/img/20200608150422.png)
线程私有
线程共享
虚拟机栈
本地方法栈
堆
方法区
标记清理算法
标记整理算法
可以有效的避免 碎片内存过多的问题
缺点：因为整体需要内存消耗时间，所以效率过低
复制算法
可以避免内存碎片的问题，但是会占用双倍的内存空间。
强软弱虚
强引用:
引用什么时候失效
生命周期结束 （作用域失效）
public void method(){
Object o=new Object();
}//方法执行结束后，强引用指向的Object对象 就会被回收置为null之后
Object=null
除了上述两种情况外，其他情况Gc都不会回收强引用对象
软引用 （SoftReference）
当GC Root指向软引用对象时
弱引用 （WeakReference）
只要gc检测到弱引用就会回收
虚引用
新生代垃圾回收器一般采用的是复制算法，复制算法的优点是效率高，缺点是内存利用率低；
老年代回收器一般采用的是标记-整理的算法进行垃圾回收。
验证
验证类是否符合JVM规范，安全性检查
准备
为static变量分配空间，设置默认值
public class HelloWorld {
static int a;
static final int b=1;
static final Object o=new Object(); //仍然在初始化阶段才会赋值
}
解析
初始化
初始化阶段就是在执行类构造器clinit()方法的过程，虚拟机会保证这个类的『构造方法』的线程安全
发生的时机
类的初始化是懒惰的，以下情况会初始化
不会导致初始化
启动类加载器
扩展类加载器
应用程序类加载器
所谓的双亲委派机制，就是指调用类加载器的loadClass方法时的规则
内连接是把匹配的关联数据显示出来；
左连接是左边的表全部显示出来，右边的表显示出符合条件的数据；右连接正好相反。
、优点
能够加快检索数据的速度，提高性能
缺点
创建索引和维护索引都需要耗费时间
当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，会降低增/改/删的执行效率；
索引适合建立在修改少，查多的列中
索引什么时候失效
select ename from emp where ename like ‘%A%’;
模糊查询的时候，第一个通配符使用的是%，这个时候索引是失效的。
视图可以隐藏表的实现细节。保密级别较高的表，只对视图对象进行CRUD。
特点
事务包括四大特性：ACID
uncommitted; 读未提交
两个客户端中，一个客户端在事务中操作数据，即使未提交，另一个客户端也能访问
committed; 读已提交
一个客户端在事务中，未提交的数据，另一个客户端无妨访问
**repeatable read; ** 可重复读(Repeated Read)：
可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在事务中，读取的数据的始终不变
**Serializable **串行读
完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞
数据表的每一列都要保持它的原子特性，也就是列不能再被分割。
表中的属性必须完全依赖于主键
所有的非主属性不依赖于其他的非主属性
void init(ServletConfig config) throws ServletException
void service(ServletRequest req, ServletResponse resp)
void destroy()
生命周期： Web容器加载Servlet并将其实例化后，Servlet生命周期开始，容器运行其init()方法进行Servlet的初始化；请求到达时调用Servlet的service()方法，service()方法会根据需要调用与请求对应的doGet或doPost等方法；当服务器关闭或项目被卸载时服务器会将Servlet实例销毁，此时会调用Servlet的destroy()方法。init方法和destroy方法只会执行一次，service方法客户端每次请求Servlet都会执行
核心：IOC AOP
IOC
AOP
@Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false），它是Spring依赖中的注解
@Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入，它是javax依赖中的注解
当您创建多个相同类型的 bean 并希望仅使用属性装配其中一个 bean 时，可以使用@Qualifier 注解和 @Autowired 通过指定应该装配哪个确切的 bean 来消除歧义。
简单类型
复杂类型
RDB 全称Redis DataBase。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wAseLKNY-1634278848244)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20211003204101823.png)]
AOF: 全名为Append Only File
AOF的文件比RDB大，并且恢复速度慢
AOF运行效率比RDB低
缓存穿透
缓存击穿
缓存雪崩
常返回后调用，要求连接点方法在执行过程中没有发生异常；
@Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false），它是Spring依赖中的注解
@Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入，它是javax依赖中的注解
当您创建多个相同类型的 bean 并希望仅使用属性装配其中一个 bean 时，可以使用@Qualifier 注解和 @Autowired 通过指定应该装配哪个确切的 bean 来消除歧义。
简单类型
复杂类型
RDB 全称Redis DataBase。
AOF: 全名为Append Only File
AOF的文件比RDB大，并且恢复速度慢
AOF运行效率比RDB低
缓存穿透
缓存击穿
缓存雪崩